fav_cli 0.0.1-alpha2

Fav's CLI, helping persist the remote source. Repo: https://github.com/kingwingfly/fav
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
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! The CLI for [bilibili](https://www.bilibili.com)

mod action;
use action::*;

use clap::{error::ErrorKind, CommandFactory as _, Parser, Subcommand, ValueHint};
use fav_core::FavCoreResult;

/// The main CLI entry point.
#[derive(Parser)]
#[command(author, version, about)]
pub struct Cli {
    #[clap(subcommand)]
    subcmd: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Initialize the folder for fav
    Init,
    /// Login your account
    Auth {
        /// Login method
        #[clap(subcommand)]
        subcmd: AuthCommands,
    },
    /// Fetch from remote
    Fetch,
    /// Show status of local, default to show resource status
    Status {
        /// Show resource status
        #[arg(value_hint = ValueHint::Other)]
        id: Option<String>,
        /// Show all sets(lists) status
        #[arg(long, short)]
        sets: bool,
        /// Show all resource(video) status
        #[arg(long, short)]
        res: bool,
        /// Show tracked only
        #[arg(long, short)]
        track: bool,
    },
    /// Track a remote source
    Track {
        /// The id of the source to track
        #[arg(value_hint = ValueHint::Other)]
        id: Vec<String>,
    },
    /// Untrack a remote source
    Untrack {
        /// The id of the source to untrack
        #[arg(value_hint = ValueHint::Other)]
        id: Vec<String>,
    },
    /// Pull remote resource to local
    Pull {
        /// The id of the source to pull
        #[arg(value_hint = ValueHint::Other)]
        id: Option<Vec<String>>,
    },
    /// Interval fetch and pull
    Daemon {
        /// The interval to fetch and pull (in minutes, greater than 15)
        #[arg(value_hint = ValueHint::Other)]
        interval: u64,
    },
    /// Completions for the shell
    Completion {
        /// The shell to generate completions for
        #[arg(value_enum)]
        shell: clap_complete::Shell,
    },
}

#[derive(Subcommand)]
enum AuthCommands {
    /// Login with password
    Login,
    /// Login with QR code
    Logout,
}

impl Cli {
    /// Run the CLI.
    pub async fn run() -> FavCoreResult<()> {
        let args = Self::parse();
        match args.subcmd {
            Commands::Init => init()?,
            subcmd => match subcmd {
                Commands::Auth { subcmd } => match subcmd {
                    AuthCommands::Login => login().await?,
                    AuthCommands::Logout => logout().await?,
                },
                Commands::Status {
                    id,
                    sets,
                    res,
                    track,
                } => match id {
                    Some(id) => {
                        if sets | res | track {
                            Cli::command()
                                .error(
                                    ErrorKind::ArgumentConflict,
                                    "The id to 'fav status' does not take -s, -r, -t, options.",
                                )
                                .exit();
                        }
                        status(id)?;
                    }
                    None => match (sets, res) {
                        (false, false) => status_all(sets, true, track)?,
                        _ => status_all(sets, res, track)?,
                    },
                },
                Commands::Fetch => fetch().await?,
                Commands::Track { id } => {
                    for id in id {
                        track(id)?;
                    }
                }
                Commands::Untrack { id } => {
                    for id in id {
                        untrack(id)?;
                    }
                }
                Commands::Pull { id } => match id {
                    Some(id) => {
                        for id in id {
                            pull(id).await?;
                        }
                    }
                    None => pull_all().await?,
                },
                Commands::Daemon { interval } => daemon(interval).await,
                Commands::Completion { shell } => {
                    let mut cmd = Cli::command();
                    clap_complete::generate(shell, &mut cmd, "fav", &mut std::io::stdout());
                }
                _ => unreachable!(),
            },
        }
        Ok(())
    }
}