caesura 0.29.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

use crate::prelude::*;
use di::ServiceProvider;
use miette::Report;
use rogue_logging::Logger;

/// 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 {
    /// Create a new [`Host`] from a configured [`ServiceProvider`].
    #[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, Report> {
        let _ = self.services.get_required::<Logger>();
        trace!("{} {}", APP_NAME, app_version_or_describe());
        let args = self.services.get_required::<ArgumentsProvider>();
        match args.get_command() {
            Command::Batch => self
                .services
                .get_required::<BatchCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Config => self
                .services
                .get_required::<ConfigCommand>()
                .execute()
                .map_err(Report::new),
            Command::Docs => Ok(self.services.get_required::<DocsCommand>().execute()),
            Command::Inspect => self
                .services
                .get_required::<InspectCommand>()
                .execute_cli()
                .map_err(Report::new),
            Command::Queue(QueueCommand::Add) => self
                .services
                .get_required::<QueueAddCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Queue(QueueCommand::Fetch) => self
                .services
                .get_required::<QueueFetchCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Queue(QueueCommand::List) => self
                .services
                .get_required::<QueueListCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Queue(QueueCommand::Remove) => self
                .services
                .get_required::<QueueRemoveCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Queue(QueueCommand::Summary) => self
                .services
                .get_required::<QueueSummaryCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Spectrogram => self
                .services
                .get_required::<SpectrogramCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Transcode => self
                .services
                .get_required::<TranscodeCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Upload => self
                .services
                .get_required::<UploadCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Verify => self
                .services
                .get_required::<VerifyCommand>()
                .execute_cli()
                .await
                .map_err(Report::new),
            Command::Version => Ok(self
                .services
                .get_required::<VersionCommand>()
                .execute()
                .await),
        }
    }
}