use crate::exercise::{Exercise, ExerciseList}; use crate::project::RustAnalyzerProject; use crate::run::run; use crate::verify::verify; use argh::FromArgs; use console::Emoji; use notify::DebouncedEvent; use notify::{RecommendedWatcher, RecursiveMode, Watcher}; use std::ffi::OsStr; use std::fs; use std::io::{self, prelude::*}; use std::path::Path; use std::process::{Command, Stdio}; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::mpsc::{channel, RecvTimeoutError}; use std::sync::{Arc, Mutex}; use std::thread; use std::time::Duration; #[macro_use] mod ui; mod exercise; mod project; mod run; mod verify; // In sync with crate version const VERSION: &str = "5.1.1"; #[derive(FromArgs, PartialEq, Debug)] /// Rustlings is a collection of small exercises to get you used to writing and reading Rust code struct Args { /// show outputs from the test exercises #[argh(switch)] nocapture: bool, /// show the executable version #[argh(switch, short = 'v')] version: bool, #[argh(subcommand)] nested: Option, } #[derive(FromArgs, PartialEq, Debug)] #[argh(subcommand)] enum Subcommands { Verify(VerifyArgs), Watch(WatchArgs), Run(RunArgs), Hint(HintArgs), List(ListArgs), Lsp(LspArgs), } #[derive(FromArgs, PartialEq, Debug)] #[argh(subcommand, name = "verify")] /// Verifies all exercises according to the recommended order struct VerifyArgs {} #[derive(FromArgs, PartialEq, Debug)] #[argh(subcommand, name = "watch")] /// Reruns `verify` when files were edited struct WatchArgs {} #[derive(FromArgs, PartialEq, Debug)] #[argh(subcommand, name = "run")] /// Runs/Tests a single exercise struct RunArgs { #[argh(positional)] /// the name of the exercise name: String, } #[derive(FromArgs, PartialEq, Debug)] #[argh(subcommand, name = "hint")] /// Returns a hint for the given exercise struct HintArgs { #[argh(positional)] /// the name of the exercise name: String, } #[derive(FromArgs, PartialEq, Debug)] #[argh(subcommand, name = "lsp")] /// Enable rust-analyzer for exercises struct LspArgs {} #[derive(FromArgs, PartialEq, Debug)] #[argh(subcommand, name = "list")] /// Lists the exercises available in Rustlings struct ListArgs { #[argh(switch, short = 'p')] /// show only the paths of the exercises paths: bool, #[argh(switch, short = 'n')] /// show only the names of the exercises names: bool, #[argh(option, short = 'f')] /// provide a string to match exercise names /// comma separated patterns are acceptable filter: Option, #[argh(switch, short = 'u')] /// display only exercises not yet solved unsolved: bool, #[argh(switch, short = 's')] /// display only exercises that have been solved solved: bool, } fn main() { let args: Args = argh::from_env(); if args.version { println!("v{}", VERSION); std::process::exit(0); } if args.nested.is_none() { println!("\n{}\n", WELCOME); } if !Path::new("info.toml").exists() { println!( "{} must be run from the rustlings directory", std::env::current_exe().unwrap().to_str().unwrap() ); println!("Try `cd rustlings/`!"); std::process::exit(1); } if !rustc_exists() { println!("We cannot find `rustc`."); println!("Try running `rustc --version` to diagnose your problem."); println!("For instructions on how to install Rust, check the README."); std::process::exit(1); } let toml_str = &fs::read_to_string("info.toml").unwrap(); let exercises = toml::from_str::(toml_str).unwrap().exercises; let verbose = args.nocapture; let command = args.nested.unwrap_or_else(|| { println!("{}\n", DEFAULT_OUT); std::process::exit(0); }); match command { Subcommands::List(subargs) => { if !subargs.paths && !subargs.names { println!("{:<17}\t{:<46}\t{:<7}", "Name", "Path", "Status"); } let mut exercises_done: u16 = 0; let filters = subargs.filter.clone().unwrap_or_default().to_lowercase(); exercises.iter().for_each(|e| { let fname = format!("{}", e.path.display()); let filter_cond = filters .split(',') .filter(|f| !f.trim().is_empty()) .any(|f| e.name.contains(&f) || fname.contains(&f)); let status = if e.looks_done() { exercises_done += 1; "Done" } else { "Pending" }; let solve_cond = { (e.looks_done() && subargs.solved) || (!e.looks_done() && subargs.unsolved) || (!subargs.solved && !subargs.unsolved) }; if solve_cond && (filter_cond || subargs.filter.is_none()) { let line = if subargs.paths { format!("{}\n", fname) } else if subargs.names { format!("{}\n", e.name) } else { format!("{:<17}\t{:<46}\t{:<7}\n", e.name, fname, status) }; // Somehow using println! leads to the binary panicking // when its output is piped. // So, we're handling a Broken Pipe error and exiting with 0 anyway let stdout = std::io::stdout(); { let mut handle = stdout.lock(); handle.write_all(line.as_bytes()).unwrap_or_else(|e| { match e.kind() { std::io::ErrorKind::BrokenPipe => std::process::exit(0), _ => std::process::exit(1), }; }); } } }); let percentage_progress = exercises_done as f32 / exercises.len() as f32 * 100.0; println!( "Progress: You completed {} / {} exercises ({:.2} %).", exercises_done, exercises.len(), percentage_progress ); std::process::exit(0); } Subcommands::Run(subargs) => { let exercise = find_exercise(&subargs.name, &exercises); run(exercise, verbose).unwrap_or_else(|_| std::process::exit(1)); } Subcommands::Hint(subargs) => { let exercise = find_exercise(&subargs.name, &exercises); println!("{}", exercise.hint); } Subcommands::Verify(_subargs) => { verify(&exercises, (0, exercises.len()), verbose).unwrap_or_else(|_| std::process::exit(1)); } Subcommands::Lsp(_subargs) => { let mut project = RustAnalyzerProject::new(); project .get_sysroot_src() .expect("Couldn't find toolchain path, do you have `rustc` installed?"); project .exercies_to_json() .expect("Couldn't parse rustlings exercises files"); if project.crates.is_empty() { println!("Failed find any exercises, make sure you're in the `rustlings` folder"); } else if project.write_to_disk().is_err() { println!("Failed to write rust-project.json to disk for rust-analyzer"); } else { println!("Successfully generated rust-project.json"); println!("rust-analyzer will now parse exercises, restart your language server or editor") } } Subcommands::Watch(_subargs) => match watch(&exercises, verbose) { Err(e) => { println!("Error: Could not watch your progress. Error message was {:?}.", e); println!("Most likely you've run out of disk space or your 'inotify limit' has been reached."); std::process::exit(1); } Ok(WatchStatus::Finished) => { println!("{emoji} All exercises completed! {emoji}", emoji = Emoji("🎉", "★")); println!("\n{}\n", FENISH_LINE); } Ok(WatchStatus::Unfinished) => { println!("We hope you're enjoying learning about Rust!"); println!("If you want to continue working on the exercises at a later point, you can simply run `rustlings watch` again"); } }, } } fn spawn_watch_shell(failed_exercise_hint: &Arc>>, should_quit: Arc) { let failed_exercise_hint = Arc::clone(failed_exercise_hint); println!("Welcome to watch mode! You can type 'help' to get an overview of the commands you can use here."); thread::spawn(move || loop { let mut input = String::new(); match io::stdin().read_line(&mut input) { Ok(_) => { let input = input.trim(); if input == "hint" { if let Some(hint) = &*failed_exercise_hint.lock().unwrap() { println!("{}", hint); } } else if input == "clear" { println!("\x1B[2J\x1B[1;1H"); } else if input.eq("quit") { should_quit.store(true, Ordering::SeqCst); println!("Bye!"); } else if input.eq("help") { println!("Commands available to you in watch mode:"); println!(" hint - prints the current exercise's hint"); println!(" clear - clears the screen"); println!(" quit - quits watch mode"); println!(" help - displays this help message"); println!(); println!("Watch mode automatically re-evaluates the current exercise"); println!("when you edit a file's contents.") } else { println!("unknown command: {}", input); } } Err(error) => println!("error reading command: {}", error), } }); } fn find_exercise<'a>(name: &str, exercises: &'a [Exercise]) -> &'a Exercise { if name.eq("next") { exercises.iter().find(|e| !e.looks_done()).unwrap_or_else(|| { println!("🎉 Congratulations! You have done all the exercises!"); println!("🔚 There are no more exercises to do next!"); std::process::exit(1) }) } else { exercises.iter().find(|e| e.name == name).unwrap_or_else(|| { println!("No exercise found for '{}'!", name); std::process::exit(1) }) } } enum WatchStatus { Finished, Unfinished, } fn watch(exercises: &[Exercise], verbose: bool) -> notify::Result { /* Clears the terminal with an ANSI escape code. Works in UNIX and newer Windows terminals. */ fn clear_screen() { println!("\x1Bc"); } let (tx, rx) = channel(); let should_quit = Arc::new(AtomicBool::new(false)); let mut watcher: RecommendedWatcher = Watcher::new(tx, Duration::from_secs(2))?; watcher.watch(Path::new("./exercises"), RecursiveMode::Recursive)?; clear_screen(); let to_owned_hint = |t: &Exercise| t.hint.to_owned(); let failed_exercise_hint = match verify(exercises.iter(), (0, exercises.len()), verbose) { Ok(_) => return Ok(WatchStatus::Finished), Err(exercise) => Arc::new(Mutex::new(Some(to_owned_hint(exercise)))), }; spawn_watch_shell(&failed_exercise_hint, Arc::clone(&should_quit)); loop { match rx.recv_timeout(Duration::from_secs(1)) { Ok(event) => match event { DebouncedEvent::Create(b) | DebouncedEvent::Chmod(b) | DebouncedEvent::Write(b) => { if b.extension() == Some(OsStr::new("rs")) && b.exists() { let filepath = b.as_path().canonicalize().unwrap(); let pending_exercises = exercises .iter() .find(|e| filepath.ends_with(&e.path)).into_iter() .chain(exercises.iter().filter(|e| !e.looks_done() && !filepath.ends_with(&e.path))); let num_done = exercises.iter().filter(|e| e.looks_done()).count(); clear_screen(); match verify(pending_exercises, (num_done, exercises.len()), verbose) { Ok(_) => return Ok(WatchStatus::Finished), Err(exercise) => { let mut failed_exercise_hint = failed_exercise_hint.lock().unwrap(); *failed_exercise_hint = Some(to_owned_hint(exercise)); } } } } _ => {} }, Err(RecvTimeoutError::Timeout) => { // the timeout expired, just check the `should_quit` variable below then loop again } Err(e) => println!("watch error: {:?}", e), } // Check if we need to exit if should_quit.load(Ordering::SeqCst) { return Ok(WatchStatus::Unfinished); } } } fn rustc_exists() -> bool { Command::new("rustc") .args(&["--version"]) .stdout(Stdio::null()) .spawn() .and_then(|mut child| child.wait()) .map(|status| status.success()) .unwrap_or(false) } const DEFAULT_OUT: &str = r#"Thanks for installing Rustlings! Is this your first time? Don't worry, Rustlings was made for beginners! We are going to teach you a lot of things about Rust, but before we can get started, here's a couple of notes about how Rustlings operates: 1. The central concept behind Rustlings is that you solve exercises. These exercises usually have some sort of syntax error in them, which will cause them to fail compilation or testing. Sometimes there's a logic error instead of a syntax error. No matter what error, it's your job to find it and fix it! You'll know when you fixed it because then, the exercise will compile and Rustlings will be able to move on to the next exercise. 2. If you run Rustlings in watch mode (which we recommend), it'll automatically start with the first exercise. Don't get confused by an error message popping up as soon as you run Rustlings! This is part of the exercise that you're supposed to solve, so open the exercise file in an editor and start your detective work! 3. If you're stuck on an exercise, there is a helpful hint you can view by typing 'hint' (in watch mode), or running `rustlings hint exercise_name`. 4. If an exercise doesn't make sense to you, feel free to open an issue on GitHub! (https://github.com/rust-lang/rustlings/issues/new). We look at every issue, and sometimes, other learners do too so you can help each other out! 5. If you want to use `rust-analyzer` with exercises, which provides features like autocompletion, run the command `rustlings lsp`. Got all that? Great! To get started, run `rustlings watch` in order to get the first exercise. Make sure to have your editor open!"#; const FENISH_LINE: &str = r#"+----------------------------------------------------+ | You made it to the Fe-nish line! | +-------------------------- ------------------------+ \\/ ▒▒ ▒▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒▒ ▒▒ ▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒▒▒ ▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒▒▒ ░░▒▒▒▒░░▒▒ ▒▒ ▒▒ ▒▒ ▒▒░░▒▒▒▒ ▓▓▓▓▓▓▓▓ ▓▓ ▓▓██ ▓▓ ▓▓██ ▓▓ ▓▓▓▓▓▓▓▓ ▒▒▒▒ ▒▒ ████ ▒▒ ████ ▒▒░░ ▒▒▒▒ ▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒ ▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▒▒▓▓▒▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒▒▒▒██▒▒▒▒▒▒██▒▒▒▒▒▒▒▒▒▒ ▒▒ ▒▒▒▒▒▒▒▒▒▒██████▒▒▒▒▒▒▒▒▒▒ ▒▒ ▒▒ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ We hope you enjoyed learning about the various aspects of Rust! If you noticed any issues, please don't hesitate to report them to our repo. You can also contribute your own exercises to help the greater community! Before reporting an issue or contributing, please read our guidelines: https://github.com/rust-lang/rustlings/blob/main/CONTRIBUTING.md"#; const WELCOME: &str = r#" welcome to... _ _ _ _ __ _ _ ___| |_| (_)_ __ __ _ ___ | '__| | | / __| __| | | '_ \ / _` / __| | | | |_| \__ \ |_| | | | | | (_| \__ \ |_| \__,_|___/\__|_|_|_| |_|\__, |___/ |___/"#;