n4n5 1.6.7

n4n5's utility crate
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

//! Watching command

use std::collections::HashSet;
use std::process::{Command, Output};

use crate::commands::Commands;
use crate::errors::GeneralError;

/// Helper to run a `Command`
/// # Errors
/// Return error if the command fails
fn run(cmd: &str, args: &[&str]) -> Result<String, String> {
    let output: Output = Command::new(cmd)
        .args(args)
        .output()
        .map_err(|e| format!("failed to execute {cmd}: {e}"))?;

    if !output.status.success() {
        return Err(format!(
            "command failed: {} {:?}\n{}",
            cmd,
            args,
            String::from_utf8_lossy(&output.stderr)
        ));
    }

    String::from_utf8(output.stdout).map_err(|e| format!("invalid UTF-8 output from {cmd}: {e}"))
}

/// Helper to split lines
fn split_lines(s: &str) -> HashSet<String> {
    s.lines()
        .map(str::trim)
        .filter(|l| !l.is_empty())
        .map(String::from)
        .collect()
}

impl Commands {
    /// Watching
    /// # Errors
    /// Returns errors if the request fails
    pub(crate) fn watching() -> Result<(), GeneralError> {
        let username = "Its-Just-Nans";

        println!("Repositories you are watching:");

        let watched_raw = run(
            "gh",
            &[
                "api",
                "-X",
                "GET",
                &format!("/users/{username}/subscriptions"),
                "-q",
                ".[].full_name",
                "--paginate",
            ],
        )?;
        println!("{watched_raw}");
        let watched = split_lines(&watched_raw);

        println!("All your repositories (excluding forks):");

        let all_raw = run(
            "gh",
            &[
                "repo",
                "list",
                username,
                "--limit",
                "10000000",
                "--source",
                "--json",
                "nameWithOwner,isFork",
                "-q",
                ".[] | select(.isFork==false) | .nameWithOwner",
            ],
        )?;

        println!("{all_raw}");
        let all = split_lines(&all_raw);

        println!("Repositories you own (not forks) but are NOT watching:");

        let mut not_watching: Vec<_> = all.difference(&watched).cloned().collect();
        not_watching.sort();

        for repo in not_watching {
            println!("{repo}");
        }

        Ok(())
    }
}