~matthiasbeyer/imag

17d2e55bfa57b3f6a2cec1e6f30154fa06484740 — Matthias Beyer 2 years ago 6f53964 + deea1d2
Merge branch 'imag-mail/main-return-result' into master

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>
2 files changed, 55 insertions(+), 79 deletions(-)

M bin/domain/imag-mail/Cargo.toml
M bin/domain/imag-mail/src/lib.rs
M bin/domain/imag-mail/Cargo.toml => bin/domain/imag-mail/Cargo.toml +1 -0
@@ 23,6 23,7 @@ maintenance                       = { status     = "actively-developed" }
log = "0.4.6"
failure = "0.1.5"
indoc = "0.3.3"
resiter = "0.4"

libimagrt       = { version = "0.10.0", path = "../../../lib/core/libimagrt" }
libimagstore    = { version = "0.10.0", path = "../../../lib/core/libimagstore" }

M bin/domain/imag-mail/src/lib.rs => bin/domain/imag-mail/src/lib.rs +54 -79
@@ 39,6 39,7 @@ extern crate clap;
#[macro_use] extern crate failure;
extern crate toml_query;
#[macro_use] extern crate indoc;
extern crate resiter;

extern crate libimagrt;
extern crate libimagmail;


@@ 51,13 52,13 @@ use std::io::Write;
use std::path::PathBuf;

use failure::Fallible as Result;
use failure::err_msg;
use failure::Error;
use toml_query::read::TomlValueReadTypeExt;
use clap::App;
use resiter::AndThen;
use resiter::IterInnerOkOrElse;

use libimagerror::trace::{MapErrTrace, trace_error};
use libimagerror::iter::TraceIterator;
use libimagerror::exit::ExitUnwrap;
use libimagerror::io::ToExitCode;
use libimagmail::mail::Mail;
use libimagmail::store::MailStore;
use libimagmail::util;


@@ 79,25 80,19 @@ mod ui;
pub enum ImagMail {}
impl ImagApplication for ImagMail {
    fn run(rt: Runtime) -> Result<()> {

                    if let Some(name) = rt.cli().subcommand_name() {

                debug!("Call {}", name);
                match name {
                    "import-mail" => import_mail(&rt),
                    "list"        => list(&rt),
                    "mail-store"  => mail_store(&rt),
                    other         => {
                        debug!("Unknown command");
                        let _ = rt.handle_unknown_subcommand("imag-mail", other, rt.cli())
                            .map_err_trace_exit_unwrap()
                            .code()
                            .map(::std::process::exit);
                    }
        match rt.cli().subcommand_name().ok_or_else(|| err_msg("No subcommand called"))? {
            "import-mail" => import_mail(&rt),
            "list"        => list(&rt),
            "mail-store"  => mail_store(&rt),
            other               => {
                debug!("Unknown command");
                if rt.handle_unknown_subcommand("imag-mail", other, rt.cli())?.success() {
                    Ok(())
                } else {
                    Err(err_msg("Failed to handle unknown subcommand"))
                }
            }

        Ok(())
            },
        }
    }

    fn build_cli<'a>(app: App<'a, 'a>) -> App<'a, 'a> {


@@ 118,9 113,9 @@ impl ImagApplication for ImagMail {
}


fn import_mail(rt: &Runtime) {
    let collection_name = get_ref_collection_name(rt).map_err_trace_exit_unwrap();
    let refconfig       = get_ref_config(rt, "imag-mail").map_err_trace_exit_unwrap();
fn import_mail(rt: &Runtime) -> Result<()> {
    let collection_name = get_ref_collection_name(rt)?;
    let refconfig       = get_ref_config(rt, "imag-mail")?;
    let scmd            = rt.cli().subcommand_matches("import-mail").unwrap();
    let store           = rt.store();



@@ 139,13 134,14 @@ fn import_mail(rt: &Runtime) {
                store.create_mail_from_path(path, &collection_name, &refconfig)
            }
            .map_info_str("Ok")
            .map_err_trace_exit_unwrap()
        })
        .for_each(|entry| rt.report_touched(entry.get_location()).unwrap_or_exit());
        .and_then_ok(|e| rt.report_touched(e.get_location()).map_err(Error::from))
        .collect::<Result<Vec<()>>>()
        .map(|_| ())
}

fn list(rt: &Runtime) {
    let refconfig       = get_ref_config(rt, "imag-mail").map_err_trace_exit_unwrap();
fn list(rt: &Runtime) -> Result<()> {
    let refconfig       = get_ref_config(rt, "imag-mail")?;
    let scmd            = rt.cli().subcommand_matches("list").unwrap(); // safe via clap
    let print_content   = scmd.is_present("list-read");



@@ 166,42 162,26 @@ fn list(rt: &Runtime) {
    fn list_mail<'a>(rt: &Runtime,
                     refconfig: &::libimagentryref::reference::Config,
                     m: &FileLockEntry<'a>,
                     print_content: bool) {

        let id = match m.get_message_id(&refconfig) {
            Ok(Some(f)) => f,
            Ok(None) => "<no id>".to_owned(),
            Err(e) => {
                trace_error(&e);
                "<error>".to_owned()
            },
                     print_content: bool) -> Result<()> {

        let id = match m.get_message_id(&refconfig)? {
            Some(f) => f,
            None => "<no id>".to_owned(),
        };

        let from = match m.get_from(&refconfig) {
            Ok(Some(f)) => f,
            Ok(None) => "<no from>".to_owned(),
            Err(e) => {
                trace_error(&e);
                "<error>".to_owned()
            },
        let from = match m.get_from(&refconfig)? {
            Some(f) => f,
            None => "<no from>".to_owned(),
        };

        let to = match m.get_to(&refconfig) {
            Ok(Some(f)) => f,
            Ok(None) => "<no to>".to_owned(),
            Err(e) => {
                trace_error(&e);
                "<error>".to_owned()
            },
        let to = match m.get_to(&refconfig)? {
            Some(f) => f,
            None => "<no to>".to_owned(),
        };

        let subject = match m.get_subject(&refconfig) {
            Ok(Some(f)) => f,
            Ok(None) => "<no subject>".to_owned(),
            Err(e) => {
                trace_error(&e);
                "<error>".to_owned()
            },
        let subject = match m.get_subject(&refconfig)? {
            Some(f) => f,
            None => "<no subject>".to_owned(),
        };

        if print_content {


@@ 209,8 189,7 @@ fn list(rt: &Runtime) {

            let content = m.as_ref_with_hasher::<MailHasher>()
                .get_path(&refconfig)
                .and_then(util::get_mail_text_content)
                .map_err_trace_exit_unwrap();
                .and_then(util::get_mail_text_content)?;

            writeln!(rt.stdout(),
                     "Mail: {id}\nFrom: {from}\nTo: {to}\n{subj}\n---\n{content}\n---\n",


@@ 219,7 198,7 @@ fn list(rt: &Runtime) {
                     subj    = subject,
                     to      = to,
                     content = content
            ).to_exit_code().unwrap_or_exit();
            )?;
        } else {
            writeln!(rt.stdout(),
                     "Mail: {id}\nFrom: {from}\nTo: {to}\n{subj}\n",


@@ 227,41 206,37 @@ fn list(rt: &Runtime) {
                     id   = id,
                     subj = subject,
                     to   = to
            ).to_exit_code().unwrap_or_exit();
            )?;
        }

        rt.report_touched(m.get_location()).unwrap_or_exit();
        rt.report_touched(m.get_location())?;
        Ok(())
    }

    if rt.ids_from_stdin() {
        let iter = rt
            .ids::<crate::ui::PathProvider>()
            .map_err_trace_exit_unwrap()
            .unwrap_or_else(|| {
                error!("No ids supplied");
                ::std::process::exit(1);
            })
            .ids::<crate::ui::PathProvider>()?
            .ok_or_else(|| err_msg("No ids supplied"))?
            .into_iter()
            .map(Ok);

        StoreIdIterator::new(Box::new(iter))
    } else {
        rt.store()
            .all_mails()
            .map_err_trace_exit_unwrap()
            .all_mails()?
            .into_storeid_iter()
    }
    .map(|id| { debug!("Found: {:?}", id); id })
    .inspect(|id| debug!("Found: {:?}", id))
    .into_get_iter(rt.store())
    .trace_unwrap_exit()
    .filter_map(|e| e)
    .for_each(|m| list_mail(&rt, &refconfig, &m, print_content));
    .map_inner_ok_or_else(|| err_msg("Did not find one entry"))
    .and_then_ok(|m| list_mail(&rt, &refconfig, &m, print_content))
    .collect::<Result<Vec<_>>>()
    .map(|_| ())
}

fn mail_store(rt: &Runtime) {
fn mail_store(rt: &Runtime) -> Result<()> {
    let _ = rt.cli().subcommand_matches("mail-store").unwrap();
    error!("This feature is currently not implemented.");
    unimplemented!()
    Err(format_err!("This feature is currently not implemented."))
}

fn get_ref_collection_name(rt: &Runtime) -> Result<String> {