caesura 0.26.0

An all-in-one command line tool to **transcode FLAC** audio files and **upload to gazelle** based indexers/trackers.
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

use di::ServiceProvider;

use rogue_logging::Error;
use rogue_logging::*;

use crate::commands::CommandArguments::Queue;
use crate::commands::CommandArguments::*;
use crate::commands::QueueCommandArguments::*;
use crate::commands::*;

/// Application host, responsible for executing the application
///
/// [`HostBuilder`] takes care of building the [Host] and loading the
/// dependency injection [`ServiceProvider`].
pub struct Host {
    /// Dependency injection service provider
    pub services: ServiceProvider,
}

impl Host {
    #[must_use]
    pub fn new(services: ServiceProvider) -> Self {
        Host { services }
    }

    /// Execute the application
    ///
    /// 1. Configure logging
    /// 2. Determine the command to execute
    /// 3. Execute the command
    pub async fn execute(&self) -> Result<bool, Error> {
        let _ = self.services.get_required::<Logger>();
        match ArgumentsParser::get_or_show_help() {
            Config => self.services.get_required::<ConfigCommand>().execute(),
            Batch { .. } => {
                self.services
                    .get_required_mut::<BatchCommand>()
                    .write()
                    .expect("BatchCommand should be available to write")
                    .execute_cli()
                    .await
            }
            Queue {
                command: Add { .. },
            } => {
                self.services
                    .get_required_mut::<QueueAddCommand>()
                    .write()
                    .expect("QueueAddCommand should be available to write")
                    .execute_cli()
                    .await
            }
            Queue {
                command: List { .. },
            } => {
                self.services
                    .get_required_mut::<QueueListCommand>()
                    .write()
                    .expect("QueueListCommand should be available to write")
                    .execute_cli()
                    .await
            }
            Queue {
                command: Remove { .. },
            } => {
                self.services
                    .get_required_mut::<QueueRemoveCommand>()
                    .write()
                    .expect("QueueRemoveCommand should be available to write")
                    .execute_cli()
                    .await
            }
            Queue {
                command: Summary { .. },
            } => {
                self.services
                    .get_required_mut::<QueueSummaryCommand>()
                    .write()
                    .expect("QueueSummaryCommand should be available to write")
                    .execute_cli()
                    .await
            }
            Spectrogram { .. } => {
                self.services
                    .get_required::<SpectrogramCommand>()
                    .execute_cli()
                    .await
            }
            Transcode { .. } => {
                self.services
                    .get_required::<TranscodeCommand>()
                    .execute_cli()
                    .await
            }
            Upload { .. } => {
                self.services
                    .get_required_mut::<UploadCommand>()
                    .write()
                    .expect("UploadCommand should be available to write")
                    .execute_cli()
                    .await
            }
            Verify { .. } => {
                self.services
                    .get_required_mut::<VerifyCommand>()
                    .write()
                    .expect("VerifyCommand should be available to write")
                    .execute_cli()
                    .await
            }
        }
    }
}