fuzzel-pass 0.1.2

/// Provides Traits allowing to parse autotype data into `wtype` parameters
/// to be used by [`Wtype`]
///
/// [`Wtype`]: crate::shell::wtype::Wtype
mod autotype;

/// Provides error management utility types
mod error;

/// provides an utility to manage password file data
mod password;

/// Provides utility to interact with system executables
mod shell;

pub use crate::autotype::Autotype;
use crate::{
    error::Error,
    password::Password,
    shell::{Result, fuzzel::Fuzzel, pass::Pass, wtype::Wtype},
};
use clap::Parser;
use std::process::ExitCode;

/// A `password-store` frontend for auto-typing passwords
#[derive(Parser)]
#[command(version, about, long_about = None)]
struct App {}

impl App {
    fn run() -> Result<()> {
        Self::parse();

        let fuzzel = Fuzzel::default();
        let password_store = Pass::default();
        let wtype = Wtype::default();

        let password_list = password_store.list()?;
        let selection = fuzzel.pick(password_list.as_str())?;
        let field_list = password_store.show(selection)?;
        let password_data: Password = field_list.parse()?;
        let key = fuzzel.pick(password_data.menu().as_str())?;
        let value = password_data.get(&key).unwrap_or_default();

        let yt_params = match (key.as_str(), value) {
            ("autotype", at_value) => {
                let at = Autotype::from((at_value, password_data));
                at.into()
            }
            (_, value) => vec![value],
        };

        wtype.send_keys(yt_params)?;

        Ok(())
    }
}

fn main() -> ExitCode {
    if let Err(ref err) = App::run() {
        return process_error(err);
    }

    ExitCode::SUCCESS
}

fn process_error(err: &Error) -> ExitCode {
    eprintln!("An error occurred: {err}");
    ExitCode::FAILURE
}