summaryrefslogtreecommitdiff
path: root/src/main.rs
blob: 65de274e2d4233f8da7f2577e72f3a01b62063a9 (plain)
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
use clap::{Args, Parser, Subcommand, ValueEnum};
use syn::{manager::Manager, PrintResult};

// #[tokio::main(flavor = "current_thread")]
// async fn main() {
//     let mut manager = Manager::load().unwrap();
//
//     let feeds = vec![
//         "https://peppe.rs/index.xml",
//         "https://jvns.ca/atom.xml",
//         // "https://www.youtube.com/feeds/videos.xml?channel_id=UCuTaETsuCOkJ0H_GAztWt0Q",
//     ];
//
//     for f in feeds {
//         match manager.add_feed(f).await {
//             Ok(s) => println!("{s}"),
//             Err(e) => println!("{e}"),
//         }
//     }
//
//     for entry in manager.list_entries() {
//         println!("{entry}");
//     }
//
//     match manager.store() {
//         Ok(s) => println!("{s}"),
//         Err(e) => eprintln!("{e}"),
//     }
//
//     // let mut feed = Feed::new(url);
//
//     // feed.resolve().await.unwrap();
//
//     // let last_read = DateTime::parse_from_rfc2822("Mon, 16 Mar 2020 18:30:00 +0000")
//     //     .unwrap()
//     //     .with_timezone(&Utc);
//
//     // feed.last_read = last_read;
//
//     // for i in feed.unread().unwrap() {
//     //     println!("{}", i.title.as_ref().unwrap().content)
//     // }
// }

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Option<Command>,
}

#[derive(Subcommand)]
enum Command {
    Add(AddCommand),
    List(ListCommand),
    Pull(PullCommand),
}

#[derive(Args)]
struct AddCommand {
    url: String,
}

#[derive(Args)]
struct ListCommand {
    #[arg(value_enum)]
    target: ListTarget,
}

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
enum ListTarget {
    Feeds,
    Entries,
}

#[derive(Args)]
struct PullCommand {
    target: Option<String>,
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let opts = Cli::parse();
    match &opts.command {
        Some(Command::Add(AddCommand { url })) => {
            let mut manager = Manager::load().unwrap_or_else(|e| {
                eprintln!("{e}");
                Manager::default()
            });

            manager.add_feed(&url).await.print();
            manager.store().print();
        }
        Some(Command::List(ListCommand { target })) => {
            let manager = Manager::load().unwrap_or_else(|e| {
                eprintln!("{e}");
                Manager::default()
            });
            match target {
                ListTarget::Feeds => manager.list_feeds().for_each(|f| println!("{f}")),
                ListTarget::Entries => manager.list_entries().for_each(|f| println!("{f}")),
            }
        }
        Some(Command::Pull(PullCommand { .. })) => {
            let mut manager = Manager::load().unwrap_or_else(|e| {
                eprintln!("{e}");
                Manager::default()
            });
            let (status, errors): (Vec<_>, Vec<_>) =
                manager.pull().await.into_iter().partition(Result::is_ok);
            status.iter().for_each(PrintResult::print);
            errors.iter().for_each(PrintResult::print);
            manager.store().print();
        }
        _ => {}
    }
}