matthiasbeyer
/
imag
1
0
Fork 0
Code Releases Activity

Merge pull request #1373 from matthiasbeyer/libimagrt/handle-unknown-subcommand 

libimagrt: Handle unknown subcommand
This commit is contained in:
Matthias Beyer 2018-04-05 09:36:31 +02:00 committed by GitHub
parent 348389f745 8c1b4124c0
commit 8492f149be
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 177 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
bin/core/imag-annotate/src/main.rs
View File

@ -57,7 +57,6 @@ use libimagrt::runtime::Runtime;
use libimagrt::setup::generate_runtime_setup;
use libimagstore::store::FileLockEntry;
use libimagstore::storeid::IntoStoreId;
use libimagutil::warn_exit::warn_exit;
mod ui;
@ -75,7 +74,13 @@ fn main() {
"add" => add(&rt),
"remove" => remove(&rt),
"list" => list(&rt),
_ => warn_exit("No commandline call", 1)
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-annotation", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(std::process::exit);
},
}
});
}

9
bin/core/imag-gps/src/main.rs
View File

@ -53,7 +53,6 @@ use libimagentrygps::types::*;
use libimagentrygps::entry::*;
use libimagrt::setup::generate_runtime_setup;
use libimagrt::runtime::Runtime;
use libimagutil::warn_exit::warn_exit;
use libimagerror::trace::MapErrTrace;
use libimagerror::exit::ExitUnwrap;
use libimagerror::io::ToExitCode;
@ -75,7 +74,13 @@ fn main() {
"add" => add(&rt),
"remove" => remove(&rt),
"get" => get(&rt),
_ => warn_exit("No commandline call", 1)
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-gps", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(::std::process::exit);
}
}
});
}

8
bin/core/imag-link/src/main.rs
View File

@ -104,7 +104,13 @@ fn main() {
"remove" => remove_linking(&rt),
"unlink" => unlink(&rt),
"list" => list_linkings(&rt),
_ => panic!("BUG"),
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-link", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(::std::process::exit);
},
}
})
.or_else(|| {

8
bin/core/imag-ref/src/main.rs
View File

@ -67,8 +67,12 @@ fn main() {
match name {
"deref" => deref(&rt),
"remove" => remove(&rt),
_ => {
debug!("Unknown command"); // More error handling
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-ref", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(::std::process::exit);
},
};
});

8
bin/core/imag-store/src/main.rs
View File

@ -50,6 +50,7 @@ extern crate libimagutil;
extern crate libimagutil;
use libimagrt::setup::generate_runtime_setup;
use libimagerror::trace::MapErrTrace;
mod create;
mod delete;
@ -92,9 +93,12 @@ fn main() {
"update" => update(&rt),
"verify" => verify(&rt),
"dump" => dump(&mut rt),
_ => {
other => {
debug!("Unknown command");
// More error handling
let _ = rt.handle_unknown_subcommand("imag-store", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(std::process::exit);
},
};
} else {

9
bin/core/imag-tag/src/main.rs
View File

@ -86,9 +86,12 @@ fn main() {
debug!("id = {:?}, add = {:?}, rem = {:?}", id, add, rem);
alter(&rt, id, add, rem);
},
_ => {
error!("Unknown command");
::std::process::exit(1)
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-tag", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(std::process::exit);
},
});
}

8
bin/domain/imag-bookmark/src/main.rs
View File

@ -77,8 +77,12 @@ fn main() {
"collection" => collection(&rt),
"list" => list(&rt),
"remove" => remove(&rt),
_ => {
debug!("Unknown command"); // More error handling
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-bookmark", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(::std::process::exit);
},
}
});

8
bin/domain/imag-contact/src/main.rs
View File

@ -102,8 +102,12 @@ fn main() {
"show" => show(&rt),
"find" => find(&rt),
"create" => create(&rt),
_ => {
error!("Unknown command"); // More error handling
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-contact", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(::std::process::exit);
},
}
});

9
bin/domain/imag-diary/src/main.rs
View File

@ -48,6 +48,7 @@ extern crate libimagtimeui;
extern crate libimagutil;
use libimagrt::setup::generate_runtime_setup;
use libimagerror::trace::MapErrTrace;
mod create;
mod delete;
@ -80,8 +81,12 @@ fn main() {
"edit" => edit(&rt),
"list" => list(&rt),
"view" => view(&rt),
_ => {
debug!("Unknown command"); // More error handling
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-diary", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(std::process::exit);
},
}
});

9
bin/domain/imag-habit/src/main.rs
View File

@ -90,9 +90,12 @@ fn main() {
"status" => today(&rt, true),
"show" => show(&rt),
"done" => done(&rt),
_ => {
debug!("Unknown command"); // More error handling
exit(1)
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-habit", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(::std::process::exit);
},
}
})

9
bin/domain/imag-log/src/main.rs
View File

@ -72,9 +72,12 @@ fn main() {
if let Some(scmd) = rt.cli() .subcommand_name() {
match scmd {
"show" => show(&rt),
_ => {
error!("Unknown command");
::std::process::exit(1)
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-log", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(std::process::exit);
},
}
} else {

8
bin/domain/imag-mail/src/main.rs
View File

@ -54,7 +54,13 @@ fn main() {
"import-mail" => import_mail(&rt),
"list" => list(&rt),
"mail-store" => mail_store(&rt),
_ => debug!("Unknown command") // More error handling
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-mail", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(std::process::exit);
}
}
});
}

8
bin/domain/imag-notes/src/main.rs
View File

@ -66,8 +66,12 @@ fn main() {
"delete" => delete(&rt),
"edit" => edit(&rt),
"list" => list(&rt),
_ => {
debug!("Unknown command"); // More error handling
other => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-notes", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(std::process::exit);
},
};
});

10
bin/domain/imag-timetrack/src/main.rs
View File

@ -56,6 +56,7 @@ use week::week;
use year::year;
use libimagrt::setup::generate_runtime_setup;
use libimagerror::trace::MapErrTrace;
fn main() {
let version = make_imag_version!();
@ -77,9 +78,12 @@ fn main() {
"track" => track(&rt),
"week" => week(&rt),
"year" => year(&rt),
_ => {
error!("Unknown command");
1
other => {
debug!("Unknown command");
rt.handle_unknown_subcommand("imag-timetrack", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.unwrap_or(0)
},
}
} else {

8
bin/domain/imag-todo/src/main.rs
View File

@ -51,10 +51,16 @@ fn main() {
match rt.cli().subcommand_name() {
Some("tw-hook") => tw_hook(&rt),
Some("list") => list(&rt),
Some(other) => {
debug!("Unknown command");
let _ = rt.handle_unknown_subcommand("imag-todo", other, rt.cli())
.map_err_trace_exit_unwrap(1)
.code()
.map(std::process::exit);
}
None => {
warn!("No command");
},
_ => unreachable!(),
} // end match scmd
} // end main

3
doc/src/09020-changelog.md
View File

@ -45,6 +45,9 @@ This section contains the changelog from the last release to the next release.
commandline flag.
* `imag-habit today --done` and `imag-habit status --done` was added for
showing habits which are already done.
* `libimagrt` allows external subcommands now in the default clap app
builder helper. It also provides a helper for handling unknown
subcommands: `Runtime::handle_unknown_subcommand()`. See docs for details.
* Minor changes
* A license-checker was included into the CI setup, which checks whether all
".rs"-files have the license header at the top of the file

77
lib/core/libimagrt/src/runtime.rs
View File

@ -24,6 +24,7 @@ use std::process::exit;
use std::io::Stdin;
pub use clap::App;
use clap::AppSettings;
use toml::Value;
use toml_query::read::TomlValueReadExt;
@ -189,6 +190,7 @@ impl<'a> Runtime<'a> {
.version(version)
.author("Matthias Beyer <mail@beyermatthias.de>")
.about(about)
.settings(&[AppSettings::AllowExternalSubcommands])
.arg(Arg::with_name(Runtime::arg_verbosity_name())
.short("v")
.long("verbose")
@ -502,6 +504,81 @@ impl<'a> Runtime<'a> {
Some(::std::io::stdin())
}
}
/// Helper for handling subcommands which are not available.
///
/// # Example
///
/// For example someone calls `imag foo bar`. If `imag-foo` is in the $PATH, but it has no
/// subcommand `bar`, the `imag-foo` binary is able to automatically forward the invokation to a
/// `imag-foo-bar` binary which might be in $PATH.
///
/// It needs to call `Runtime::handle_unknown_subcommand` with the following parameters:
///
/// 1. The "command" which was issued. In the example this would be `"imag-foo"`
/// 2. The "subcommand" which is missing: `"bar"` in the example
/// 3. The `ArgMatches` object from the call, so that this routine can forward all flags passed
/// to the `bar` subcommand.
///
/// # Return value
///
/// On success, the exit status object of the `Command` invocation is returned.
/// On Error, a RuntimeError object is returned.
///
/// # Details
///
/// The `IMAG_RTP` variable is set for the child process. It is set to the current runtime path.
///
/// Stdin, stdout and stderr are inherited to the child process.
///
/// This function **blocks** until the child returns.
///
pub fn handle_unknown_subcommand<S: AsRef<str>>(&self,
command: S,
subcommand: S,
args: &ArgMatches)
-> Result<::std::process::ExitStatus, RuntimeError>
{
use std::io::Write;
use std::io::ErrorKind;
let rtp_str = self.rtp()
.to_str()
.map(String::from)
.ok_or(RuntimeErrorKind::IOError)
.map_err(RuntimeError::from_kind)?;
let command = format!("{}-{}", command.as_ref(), subcommand.as_ref());
let subcommand_args = args.values_of("")
.map(|sx| sx.map(String::from).collect())
.unwrap_or_else(|| vec![]);
Command::new(&command)
.stdin(::std::process::Stdio::inherit())
.stdout(::std::process::Stdio::inherit())
.stderr(::std::process::Stdio::inherit())
.args(&subcommand_args[..])
.env("IMAG_RTP", rtp_str)
.spawn()
.and_then(|mut c| c.wait())
.map_err(|e| match e.kind() {
ErrorKind::NotFound => {
let mut out = self.stdout();
if let Err(e) = writeln!(out, "No such command: '{}'", command) {
return e;
}
if let Err(e) = writeln!(out, "See 'imag --help' for available subcommands") {
return e;
}
e
},
_ => e,
})
.map_err(RuntimeError::from)
}
}
/// Exported for the `imag` command, you probably do not want to use that.