scootaloo/src/main.rs

use clap::{App, Arg, SubCommand};
use log::{error, LevelFilter};
use scootaloo::*;
use simple_logger::SimpleLogger;
use std::str::FromStr;

const DEFAULT_CONFIG_PATH: &str = "/usr/local/etc/scootaloo.toml";

fn main() {
    let matches = App::new(env!("CARGO_PKG_NAME"))
        .version(env!("CARGO_PKG_VERSION"))
        .about("A Twitter to Mastodon bot")
        .arg(
            Arg::with_name("config")
                .short("c")
                .long("config")
                .value_name("CONFIG_FILE")
                .help(&format!(
                    "TOML config file for scootaloo (default {})",
                    DEFAULT_CONFIG_PATH
                ))
                .takes_value(true)
                .display_order(1),
        )
        .arg(
            Arg::with_name("log_level")
                .short("l")
                .long("loglevel")
                .value_name("LOGLEVEL")
                .help("Log level. Valid values are: Off, Warn, Error, Info, Debug")
                .takes_value(true)
                .display_order(2),
        )
        .subcommand(
            SubCommand::with_name("register")
                .version(env!("CARGO_PKG_VERSION"))
                .about("Command to register to a Mastodon Instance")
                .arg(
                    Arg::with_name("host")
                        .short("H")
                        .long("host")
                        .value_name("HOST")
                        .help("Base URL of the Mastodon instance to register to (no default)")
                        .takes_value(true)
                        .required(true)
                        .display_order(1)
                    )
                .arg(
                    Arg::with_name("name")
                        .short("n")
                        .long("name")
                        .help("Twitter Screen Name (like https://twitter.com/screen_name, no default)")
                        .takes_value(true)
                        .required(true)
                        .display_order(2)
                ),
        )
        .subcommand(
            SubCommand::with_name("init")
                .version(env!("CARGO_PKG_VERSION"))
                .about("Command to init Scootaloo DB")
                .arg(
                    Arg::with_name("config")
                        .short("c")
                        .long("config")
                        .value_name("CONFIG_FILE")
                        .help(&format!(
                            "TOML config file for scootaloo (default {})",
                            DEFAULT_CONFIG_PATH
                        ))
                        .takes_value(true)
                        .display_order(1),
                ),
        )
        .subcommand(
            SubCommand::with_name("migrate")
            .version(env!("CARGO_PKG_VERSION"))
            .about("Command to migrate Scootaloo DB")
            .arg(
                Arg::with_name("config")
                    .short("c")
                    .long("config")
                    .value_name("CONFIG_FILE")
                    .help(&format!("TOML config file for scootaloo (default {})", DEFAULT_CONFIG_PATH))
                    .takes_value(true)
                    .display_order(1),
            )
            .arg(
                    Arg::with_name("name")
                        .short("n")
                        .long("name")
                        .help("Twitter Screen Name (like https://twitter.com/screen_name, no default)")
                        .takes_value(true)
                        .display_order(2)
            )
        )
        .get_matches();

    match matches.subcommand() {
        ("register", Some(sub_m)) => {
            register(
                sub_m.value_of("host").unwrap(),
                sub_m.value_of("name").unwrap(),
            );
            return;
        }
        ("init", Some(sub_m)) => {
            let config = parse_toml(sub_m.value_of("config").unwrap_or(DEFAULT_CONFIG_PATH));
            init_db(&config.scootaloo.db_path).unwrap();
            return;
        }
        ("migrate", Some(sub_m)) => {
            let config = parse_toml(sub_m.value_of("config").unwrap_or(DEFAULT_CONFIG_PATH));
            let config_twitter_screen_name =
                &config.mastodon.values().next().unwrap().twitter_screen_name;
            migrate_db(
                &config.scootaloo.db_path,
                sub_m.value_of("name").unwrap_or(config_twitter_screen_name),
            )
            .unwrap();
            return;
        }
        _ => (),
    }

    if matches.is_present("log_level") {
        match LevelFilter::from_str(matches.value_of("log_level").unwrap()) {
            Ok(level) => SimpleLogger::new().with_level(level).init().unwrap(),
            Err(e) => {
                SimpleLogger::new()
                    .with_level(LevelFilter::Error)
                    .init()
                    .unwrap();
                error!("Unknown log level filter: {}", e);
            }
        };
    }

    let config = parse_toml(matches.value_of("config").unwrap_or(DEFAULT_CONFIG_PATH));

    run(config);
}