podcast 0.18.0

A command line podcast manager
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

use crate::{executor, structs::State};
use anyhow::Result;
use clap::{Command, ArgMatches};

pub enum CommandC<'a> {
    Download(State, ArgMatches),
    List(State, ArgMatches),
    Play(State, ArgMatches),
    Subscribe(State, ArgMatches),
    Search(State, ArgMatches),
    Remove(State, ArgMatches),
    Complete(State, Command<'a>, ArgMatches),
    Refresh(State),
    Update(State),
    NoMatch(State),
}

pub fn parse_command<'a>(state: State, app: Command<'a>, matches: ArgMatches) -> CommandC<'a> {
    let state_copy = state.clone();
    matches
        .subcommand_name()
        .map(|command| match command {
            "download" => CommandC::Download(
                state,
                matches.subcommand_matches("download").unwrap().clone(),
            ),
            "ls" | "list" => CommandC::List(
                state,
                matches
                    .subcommand_matches("ls")
                    .or_else(|| matches.subcommand_matches("list"))
                    .unwrap()
                    .clone(),
            ),
            "play" => CommandC::Play(state, matches.subcommand_matches("play").unwrap().clone()),
            "sub" | "subscribe" => CommandC::Subscribe(
                state,
                matches
                    .subcommand_matches("sub")
                    .or_else(|| matches.subcommand_matches("subscribe"))
                    .unwrap()
                    .clone(),
            ),
            "search" => {
                CommandC::Search(state, matches.subcommand_matches("search").unwrap().clone())
            }
            "rm" => CommandC::Remove(state, matches.subcommand_matches("rm").unwrap().clone()),
            "completion" => CommandC::Complete(
                state,
                app,
                matches.subcommand_matches("completion").unwrap().clone(),
            ),
            "refresh" => CommandC::Refresh(state),
            "update" => CommandC::Update(state),
            _ => CommandC::NoMatch(state),
        })
        .unwrap_or_else(|| CommandC::NoMatch(state_copy))
}

pub async fn run_command<'a>(command: CommandC<'a>) -> Result<State> {
    match command {
        CommandC::Download(state, matches) => executor::download(state, &matches).await,
        CommandC::List(state, matches) => executor::list(state, &matches),
        CommandC::Play(state, matches) => executor::play(state, &matches),
        CommandC::Subscribe(state, matches) => executor::subscribe(state, &matches).await,
        CommandC::Search(state, matches) => executor::search(state, &matches).await,
        CommandC::Remove(state, matches) => executor::remove(state, &matches),
        CommandC::Complete(state, mut app, matches) => {
            executor::complete(&mut app, &matches)?;
            Ok(state)
        }
        CommandC::Refresh(mut state) => {
            state.update_rss().await?;
            Ok(state)
        }
        CommandC::Update(state) => {
            state.check_for_update().await?;
            Ok(state)
        }
        CommandC::NoMatch(state) => Ok(state),
    }
}