https://rust-lang-nursery.github.io/cli-wg/ – tracking repo: https://github.com/rust-lang-nursery/cli-wg/issues
I approximated it with putting the happy path and the update path in an arg group --
error: The following required arguments were not provided:
<query|--self-update>
USAGE:
agrind [FLAGS] [OPTIONS] <query|--self-update>
but it would be nice if it just behaved like version behaves
use failure::ResultExt;
use exitfailure::ExitFailure;
fn main() -> Result<(), ExitFailure> {
let path = "test.txt";
let content = std::fs::read_to_string(path)
.with_context(|_| format!("could not read file `{}`", path))?;
println!("file content: {}", content);
Ok(())
}
at least i think they are the most recent :) the code is tested with this config btw: https://github.com/rust-lang-nursery/cli-wg/blob/25f1851e3885fff97d3e4bd375ae79157074ceb0/Cargo.toml#L66-L67
the current version is at the "i think i wrote enough to cover the basics" stage, and I want to get back to adding more content as well as copy-editing soon, so any kind of feedback is super appreciated :) (here, as github issues, emails, in english or german… postcards in swedish might take me a while to respond to, but i promise i'll try)
@killercup
- Chapter 1.5 contains code like this
do_hard_work()(Showing a progress bar). When this book is more by example than this is a problem. Because I (newbee) can't try this code. Tried alredy to implement some downloader of files but got problems with open_ssl being included by many crates. - Chapter 1.6 Testing Suddenly the difficulty increases for me. So I tend to close this chapter and never look in to it.
Would be good to comment directly on the book content. And discuss it there on github.
there is a never-to-be-merged PR here rust-lang-nursery/cli-wg#58 to allow comments on the diff
not sure how to give a good progress bar code example for downloading without also having to go into a lot of details around http/async… you can find some examples here, tho: https://github.com/mitsuhiko/indicatif/tree/master/examples
@dkotrada can you say where the testing chapter got difficult for you?
@killercup Geht auch in deutsch?
Trying to follow the cli-wg tutorial, this is my implementation: https://github.com/crodjer/grrs/blob/master/src/main.rs#L23
I am using BufReader to avoid copying lines:
let lines = BufReader::new(f)
.lines()
.filter(Result::is_ok)
.map(Result::unwrap);I then feed this iterator to my library function to find_matches:
pub fn find_matches<I>(lines: I, pattern: &str) -> Vec<String>
where
I: Iterator<Item = String>,
{
lines.filter(|line| line.contains(&pattern)).collect()
}But, I want to avoid return a vector and want to return an iterator which main can then lazily render. After removing collect, I am unable to figure out the type signatures.
How can I modify
find_matches so that I only deal with lazy iterators?
Okay, so this works:
pub fn find_matches<'a, I: 'a>(lines: I, pattern: &'a str) -> impl Iterator<Item = String> + 'a
where
I: Iterator<Item = String>,
{
lines.filter(move |line| line.contains(pattern))
}Based on: https://stackoverflow.com/a/27649089. Don't know why though.
Also, shouldn't rust have Sized issues with this? Given the type signature just has the trait.
If it were "this function returns any type that implements Iterator", then yeah, there would be Sized issues because there's lots of different types that may implement Iterator and they have different sizes.
This particular syntax means "this function returns one particular type that implements Iterator, but I won't write its name". The compiler can validate that the function only ever returns one particular type, and the compiler knows what type that is, so the compiler knows what the size is and all is well.
@crodjer that's a very good solution! tbh, i had never fully implemented the tool with all features and lazy streaming… :sweat_smile: thanks for doing that!
you can read more on the impl Trait feature in RFC #1522 and an expansion of it in RFC #1951
you also can write find_matches like this if you want the param and return type to be more symmetrical:
pub fn find_matches<'a>(
lines: impl Iterator<Item = String> + 'a,
pattern: &'a str,
) -> impl Iterator<Item = String> + 'a {
lines.filter(move |line| line.contains(pattern))
}
oh, and instead of doing
.filter(Result::is_ok).map(Result::unwrap) you can also .filter_map(Result::ok) by the way
@killercup Thanks for the tutorial. It was very helpful in getting my hands wet with Rust and cli.
Published the crate at: https://crates.io/crates/grrs-lazy
Published the crate at: https://crates.io/crates/grrs-lazy
good idea to publish it! maybe other people following the tutorial will find your crate and get some inspiration or see how you did the lazy iteration :)
Trying to modify channels based signal handle from the book to handle dual Ctrl-C signals. I have a way with mutexes and threads, but I feel there may be a better way to do this instead:
let status = Arc::new(Mutex::new(0));
loop {
if *status.lock().unwrap() >= 2 {
break;
}
select! {
recv(ticks) -> _ => {
println!("working!");
}
recv(ctrl_c_events) -> _ => {
let status = status.clone();
*status.lock().unwrap() += 1;
thread::spawn(move || {
println!("Shutting down...");
thread::sleep(Duration::from_secs(2));
println!("Goodbye!");
*status.lock().unwrap() += 1;
});
}
}
}
Hi all! I'm working on a simple CLI app and have gotten to writing the man(1) page for the app, so I'm looking for the current best way to do so. I found https://github.com/rust-clique/man ; is that the best option? I'm asking because it looks like that repo isn't that active—no commits in a couple of months, and the README example doesn't work (e.g., it uses the
.description method instead of the .help method in the code.
I also found https://rust-lang-nursery.github.io/cli-wg/in-depth/docs.html, which discusses rendering man pages from Clap, but that doesn't seem to be implemented (yet?)