git-codeowners 0.1.2

Rust cli for working with Github CODEOWNERS files
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

extern crate codeowners;
extern crate clap;

use codeowners::Owner;
use clap::{App, Arg};
use std::path::Path;
use std::process::exit;
use std::io::{self, BufRead};

fn main() {
    let matches = App::new(env!("CARGO_PKG_NAME"))
        .version(env!("CARGO_PKG_VERSION"))
        .about("Github CODEOWNERS answer sheet")
        .arg(
            Arg::with_name("codeowners")
                .help("An explicit path for a CODEOWNERS file. program will exit 1 if file can not be resolved")
                .takes_value(true)
                .short("c")
                .long("codeowners"),
        )
        .arg(
            Arg::with_name("teams")
                .help("Only return teams")
                .short("t")
                .long("teams")
                .conflicts_with("users")
                .conflicts_with("emails"),
        )
        .arg(
            Arg::with_name("users")
                .help("Only return users")
                .short("u")
                .long("users")
                .conflicts_with("teams")
                .conflicts_with("emails"),
        )
        .arg(
            Arg::with_name("emails")
                .help("Only return emails")
                .short("e")
                .long("emails")
                .conflicts_with("teams")
                .conflicts_with("users"),
        )
        .arg(
            Arg::with_name("path")
                .help(
                    "Path of file in git repo. if '-' is provided path will \
                     be read from stdin. program will exit 2 if no owners can \
                     be resolved",
                )
                .index(1)
                .required(true),
        )
        .get_matches();
    let ownersfile = match matches.value_of("codeowners") {
        Some(path) => {
            let p = Path::new(path);
            if p.exists() {
                Some(p.to_path_buf())
            } else {
                None
            }
        }
        _ => codeowners::locate("."),
    };
    match ownersfile {
        Some(file) => {
            let resolve = |path: &str| {
                let owners = codeowners::from_path(file.clone());
                let (teams, users, emails) = (
                    matches.occurrences_of("teams") > 0,
                    matches.occurrences_of("users") > 0,
                    matches.occurrences_of("emails") > 0,
                );
                match owners.of(path) {
                    None => exit(2),
                    Some(owners) => {
                        let owned = owners
                            .iter()
                            .filter_map(|owner| if teams {
                                match owner {
                                    &Owner::Team(ref inner) => Some(inner.clone()),
                                    _ => None,
                                }
                            } else if users {
                                match owner {
                                    &Owner::Username(ref inner) => Some(inner.clone()),
                                    _ => None,
                                }
                            } else if emails {
                                match owner {
                                    &Owner::Email(ref inner) => Some(inner.clone()),
                                    _ => None,
                                }
                            } else {
                                Some(owner.to_string())
                            })
                            .collect::<Vec<_>>();
                        if owned.is_empty() {
                            exit(2)
                        } else {
                            println!("{}", owned.join(" "));
                        }
                    }
                }
            };
            match matches.value_of("path").unwrap().as_ref() {
                "-" => {
                    let stdin = io::stdin();
                    for path in stdin.lock().lines().filter_map(Result::ok) {
                        resolve(&path);
                    }
                }
                path => resolve(path),
            }
        }
        _ => exit(1),
    }

}