oxyromon 0.4.0

Rusty ROM OrgaNizer
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

extern crate async_std;
extern crate cfg_if;
extern crate clap;
extern crate crc32fast;
extern crate digest;
extern crate dirs;
extern crate dotenv;
extern crate indicatif;
extern crate once_cell;
extern crate quick_xml;
extern crate refinery;
extern crate regex;
extern crate serde;
extern crate sqlx;
#[macro_use]
extern crate simple_error;
extern crate rayon;
extern crate tempfile;

mod chdman;
mod checksum;
mod config;
mod convert_roms;
mod database;
mod import_dats;
mod import_roms;
mod maxcso;
mod model;
mod progress;
mod prompt;
mod purge_roms;
mod sevenzip;
mod sort_roms;
mod util;

mod embedded {
    use refinery::embed_migrations;
    embed_migrations!("migrations");
}

use async_std::path::PathBuf;
use clap::App;
use database::*;
use dotenv::dotenv;
use refinery::config::{Config, ConfigDbType};
use simple_error::SimpleError;
use util::*;

type SimpleResult<T> = Result<T, SimpleError>;

#[async_std::main]
async fn main() -> SimpleResult<()> {
    let matches = App::new(env!("CARGO_BIN_NAME"))
        .version(env!("CARGO_PKG_VERSION"))
        .about(env!("CARGO_PKG_DESCRIPTION"))
        .author(env!("CARGO_PKG_AUTHORS"))
        .subcommands(vec![
            config::subcommand(),
            import_dats::subcommand(),
            import_roms::subcommand(),
            sort_roms::subcommand(),
            convert_roms::subcommand(),
            purge_roms::subcommand(),
        ])
        .get_matches();

    if matches.subcommand.is_some() {
        dotenv().ok();

        let data_directory = PathBuf::from(dirs::data_dir().unwrap()).join("oxyromon");
        create_directory(&data_directory).await?;

        let db_file = data_directory.join("oxyromon.db");
        if !db_file.is_file().await {
            create_file(&db_file).await?;
        }
        let mut connection = establish_connection(db_file.as_os_str().to_str().unwrap()).await;

        let mut config =
            Config::new(ConfigDbType::Sqlite).set_db_path(db_file.as_os_str().to_str().unwrap());
        embedded::migrations::runner().run(&mut config).unwrap();

        match matches.subcommand_name() {
            Some("config") => {
                config::main(
                    &mut connection,
                    &matches.subcommand_matches("config").unwrap(),
                )
                .await?
            }
            Some("import-dats") => {
                import_dats::main(
                    &mut connection,
                    &matches.subcommand_matches("import-dats").unwrap(),
                )
                .await?
            }
            Some("import-roms") => {
                import_roms::main(
                    &mut connection,
                    &matches.subcommand_matches("import-roms").unwrap(),
                )
                .await?
            }
            Some("sort-roms") => {
                sort_roms::main(
                    &mut connection,
                    &matches.subcommand_matches("sort-roms").unwrap(),
                )
                .await?
            }
            Some("convert-roms") => {
                convert_roms::main(
                    &mut connection,
                    &matches.subcommand_matches("convert-roms").unwrap(),
                )
                .await?
            }
            Some("purge-roms") => {
                purge_roms::main(
                    &mut connection,
                    &matches.subcommand_matches("purge-roms").unwrap(),
                )
                .await?
            }
            _ => (),
        }

        close_connection(&mut connection).await;
    }

    Ok(())
}