wfassoc/wfassoc_exec/src/main.rs

pub(crate) mod cli;
pub(crate) mod manifest;

use clap::Parser;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::process;
use std::str::FromStr;
use thiserror::Error as TeError;
use wfassoc::{Program, Token};
use cli::{Cli, Commands};
use manifest::Manifest;

// region: Basic Types

/// All errors occurs in this executable.
#[derive(TeError, Debug)]
enum Error {
    /// Error from wfassoc core.
    #[error("{0}")]
    Core(#[from] wfassoc::Error),
    /// Error when parsing manifest TOML file.
    #[error("invalid manifest file: {0}")]
    Manifest(#[from] manifest::Error),

    /// Error when specifying invalid manner name for extension.
    #[error("extension {ext} associated manner {manner} is invalid in manifest file")]
    InvalidMannerName {
        manner: String,
        ext: String
    },
}

/// Result type used in this executable.
type Result<T> = std::result::Result<T, Error>;

// endregion

// region: Correponding Runner

fn build_program(cli: &Cli) -> Result<Program> {
    // Open file and read manifest TOML file
    let mf = Manifest::from_file(&cli.config_file)?;
    // Create instance
    let mut rv = Program::new(&mf.identifier, PathBuf::from_str(&cli.config_file).unwrap().as_path())?;
    // Setup manner
    let mut manners: HashMap<&str, Token> = HashMap::new();
    for (k, v) in mf.manners.iter() {
        let token = rv.add_manner(v.as_str())?;
        manners.insert(k.as_str(), token);
    }
    // Setup extension
    for (k, v) in mf.exts.iter() {
        let token = match manners.get(v.as_str()) {
            Some(v) => v,
            None => return Err(Error::InvalidMannerName { manner: v.to_string(), ext: k.clone() }),
        };
        rv.add_ext(k.as_str(), *token)?;
    }
    // Okey
    Ok(rv)
}

fn run_register(cli: &Cli) -> Result<()> {
    // let program = Program::new();
    // let kind: RegisterKind = cli.for_which.into();
    // program.register(kind)?;
    Ok(())
}

fn run_unregister(cli: &Cli) -> Result<()> {
    // let program = Program::new();
    // program.unregister()?;
    Ok(())
}

fn run_query(cli: &Cli) -> Result<()> {
    let program = build_program(cli)?;
    print!("{:?}", program);
    Ok(())
}

// endregion

fn main() {
    let cli = Cli::parse();

    let rv = match &cli.command {
        Commands::Register => run_register(&cli),
        Commands::Unregister => run_unregister(&cli),
        Commands::Query => run_query(&cli),
    };
    rv.unwrap_or_else(|e| {
        eprintln!("Runtime error: {}.", e);
        process::exit(1)
    });
}