caesura 0.11.2

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

use crate::batch::BatchCommand;
use di::ServiceProvider;

use crate::cli::ArgumentsParser;
use crate::cli::CommandArguments::*;
use crate::errors::AppError;
use crate::logging::*;
use crate::spectrogram::SpectrogramCommand;
use crate::transcode::TranscodeCommand;
use crate::upload::UploadCommand;
use crate::verify::VerifyCommand;

/// 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, AppError> {
        let logger = self.services.get_required::<Logger>();
        Logger::init(logger);
        match ArgumentsParser::get_or_show_help() {
            Batch { .. } => {
                self.services
                    .get_required_mut::<BatchCommand>()
                    .write()
                    .expect("BatchCommand should be available to write")
                    .execute()
                    .await
            }
            Spectrogram { .. } => {
                self.services
                    .get_required::<SpectrogramCommand>()
                    .execute()
                    .await
            }
            Transcode { .. } => {
                self.services
                    .get_required::<TranscodeCommand>()
                    .execute()
                    .await
            }
            Upload { .. } => {
                self.services
                    .get_required_mut::<UploadCommand>()
                    .write()
                    .expect("UploadCommand should be available to write")
                    .execute()
                    .await
            }
            Verify { .. } => {
                self.services
                    .get_required_mut::<VerifyCommand>()
                    .write()
                    .expect("VerifyCommand should be available to write")
                    .execute()
                    .await
            }
        }
    }
}