rustlings/src/main.rs

253 lines
10 KiB
Rust
Raw Normal View History

use crate::exercise::{Exercise, ExerciseList};
2019-01-09 22:33:58 +03:00
use crate::run::run;
use crate::verify::verify;
use clap::{crate_version, App, Arg, SubCommand};
use console::Emoji;
2019-01-09 22:33:58 +03:00
use notify::DebouncedEvent;
use notify::{RecommendedWatcher, RecursiveMode, Watcher};
2019-03-06 21:38:55 +03:00
use std::ffi::OsStr;
use std::fs;
2019-11-18 20:11:22 +03:00
use std::io;
use std::path::Path;
use std::process::{Command, Stdio};
use std::sync::mpsc::channel;
2019-11-18 20:11:22 +03:00
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
2019-01-09 22:33:43 +03:00
#[macro_use]
mod ui;
mod exercise;
2019-01-09 22:33:43 +03:00
mod run;
2019-01-09 22:33:58 +03:00
mod verify;
2018-05-14 19:41:58 +03:00
2018-11-09 22:31:14 +03:00
fn main() {
let matches = App::new("rustlings")
2018-11-14 22:12:20 +03:00
.version(crate_version!())
2019-01-23 23:43:32 +03:00
.author("Olivia Hugger, Carol Nichols")
.about("Rustlings is a collection of small exercises to get you used to writing and reading Rust code")
2020-06-04 00:19:28 +03:00
.arg(
Arg::with_name("nocapture")
.long("nocapture")
.help("Show outputs from the test exercises")
2020-06-04 00:19:28 +03:00
)
.subcommand(
SubCommand::with_name("verify")
.alias("v")
.about("Verifies all exercises according to the recommended order")
)
.subcommand(
SubCommand::with_name("watch")
.alias("w")
.about("Reruns `verify` when files were edited")
)
2018-11-23 17:18:43 +03:00
.subcommand(
SubCommand::with_name("run")
.alias("r")
2019-01-23 23:43:32 +03:00
.about("Runs/Tests a single exercise")
.arg(Arg::with_name("name").required(true).index(1)),
2019-01-09 22:33:58 +03:00
)
.subcommand(
SubCommand::with_name("hint")
.alias("h")
.about("Returns a hint for the current exercise")
.arg(Arg::with_name("name").required(true).index(1)),
)
2020-11-10 20:36:19 +03:00
.subcommand(
SubCommand::with_name("list")
.alias("l")
.about("Lists the exercises available in rustlings")
)
2019-01-09 22:33:58 +03:00
.get_matches();
2018-11-14 22:12:20 +03:00
2020-06-04 00:19:28 +03:00
if matches.subcommand_name().is_none() {
2019-03-11 17:09:20 +03:00
println!();
2019-01-09 22:44:55 +03:00
println!(r#" welcome to... "#);
println!(r#" _ _ _ "#);
println!(r#" _ __ _ _ ___| |_| (_)_ __ __ _ ___ "#);
println!(r#" | '__| | | / __| __| | | '_ \ / _` / __| "#);
println!(r#" | | | |_| \__ \ |_| | | | | | (_| \__ \ "#);
println!(r#" |_| \__,_|___/\__|_|_|_| |_|\__, |___/ "#);
println!(r#" |___/ "#);
2019-03-11 17:09:20 +03:00
println!();
2019-01-09 22:44:55 +03:00
}
2018-11-14 22:12:20 +03:00
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::<ExerciseList>(toml_str).unwrap().exercises;
let verbose = matches.is_present("nocapture");
2020-11-10 20:36:19 +03:00
if matches.subcommand_matches("list").is_some() {
exercises.iter().for_each(|e| println!("{}", e.name));
}
if let Some(ref matches) = matches.subcommand_matches("run") {
2019-11-11 19:47:45 +03:00
let name = matches.value_of("name").unwrap();
2019-11-11 19:19:50 +03:00
let matching_exercise = |e: &&Exercise| name == e.name;
2019-04-13 00:24:13 +03:00
let exercise = exercises.iter().find(matching_exercise).unwrap_or_else(|| {
println!("No exercise found for your given name!");
2019-04-13 00:24:13 +03:00
std::process::exit(1)
});
run(&exercise, verbose).unwrap_or_else(|_| std::process::exit(1));
2018-11-23 17:18:43 +03:00
}
if let Some(ref matches) = matches.subcommand_matches("hint") {
2019-11-11 19:47:45 +03:00
let name = matches.value_of("name").unwrap();
2019-11-11 19:19:50 +03:00
let exercise = exercises
.iter()
.find(|e| name == e.name)
.unwrap_or_else(|| {
println!("No exercise found for your given name!");
std::process::exit(1)
});
println!("{}", exercise.hint);
}
2019-03-11 17:09:20 +03:00
if matches.subcommand_matches("verify").is_some() {
verify(&exercises, verbose).unwrap_or_else(|_| std::process::exit(1));
}
if matches.subcommand_matches("watch").is_some() {
if let Err(e) = watch(&exercises, verbose) {
println!("Error: Could not watch your progess. 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);
}
2020-06-04 00:19:28 +03:00
println!(
"{emoji} All exercises completed! {emoji}",
emoji = Emoji("🎉", "")
);
println!();
2020-11-12 01:06:14 +03:00
println!("+----------------------------------------------------+");
println!("| You made it to the Fe-nish line! |");
println!("+-------------------------- ------------------------+");
println!(" \\/ ");
println!(" ▒▒ ▒▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒▒ ▒▒ ");
println!(" ▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒▒▒ ");
println!(" ▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒▒▒ ");
println!(" ░░▒▒▒▒░░▒▒ ▒▒ ▒▒ ▒▒ ▒▒░░▒▒▒▒ ");
println!(" ▓▓▓▓▓▓▓▓ ▓▓ ▓▓██ ▓▓ ▓▓██ ▓▓ ▓▓▓▓▓▓▓▓ ");
println!(" ▒▒▒▒ ▒▒ ████ ▒▒ ████ ▒▒░░ ▒▒▒▒ ");
println!(" ▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒ ");
println!(" ▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▒▒▓▓▒▒▒▒▒▒▒▒ ");
println!(" ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ");
println!(" ▒▒▒▒▒▒▒▒▒▒██▒▒▒▒▒▒██▒▒▒▒▒▒▒▒▒▒ ");
println!(" ▒▒ ▒▒▒▒▒▒▒▒▒▒██████▒▒▒▒▒▒▒▒▒▒ ▒▒ ");
println!(" ▒▒ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▒▒ ");
println!(" ▒▒ ▒▒ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▒▒ ▒▒ ");
println!(" ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ");
println!(" ▒▒ ▒▒ ▒▒ ▒▒ ");
println!();
2020-06-04 00:19:28 +03:00
println!("We hope you enjoyed learning about the various aspects of Rust!");
2020-08-10 17:42:54 +03:00
println!("If you noticed any issues, please don't hesitate to report them to our repo.");
2020-06-04 00:19:28 +03:00
println!("You can also contribute your own exercises to help the greater community!");
println!();
println!("Before reporting an issue or contributing, please read our guidelines:");
println!("https://github.com/rust-lang/rustlings/blob/main/CONTRIBUTING.md");
2018-11-14 22:12:20 +03:00
}
2019-03-11 17:09:20 +03:00
if matches.subcommand_name().is_none() {
2019-06-05 13:18:50 +03:00
let text = fs::read_to_string("default_out.txt").unwrap();
println!("{}", text);
}
2018-05-06 19:59:50 +03:00
}
2019-11-18 20:11:22 +03:00
fn spawn_watch_shell(failed_exercise_hint: &Arc<Mutex<Option<String>>>) {
let failed_exercise_hint = Arc::clone(failed_exercise_hint);
println!("Type 'hint' to get help or 'clear' to clear the screen");
2019-11-18 20:11:22 +03:00
thread::spawn(move || loop {
let mut input = String::new();
match io::stdin().read_line(&mut input) {
Ok(_) => {
let input = input.trim();
if input.eq("hint") {
2019-11-18 20:11:22 +03:00
if let Some(hint) = &*failed_exercise_hint.lock().unwrap() {
println!("{}", hint);
}
} else if input.eq("clear") {
println!("\x1B[2J\x1B[1;1H");
2019-11-18 20:11:22 +03:00
} else {
println!("unknown command: {}", input);
}
}
Err(error) => println!("error reading command: {}", error),
}
});
}
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 mut watcher: RecommendedWatcher = Watcher::new(tx, Duration::from_secs(2))?;
2019-03-27 12:58:56 +03:00
watcher.watch(Path::new("./exercises"), RecursiveMode::Recursive)?;
clear_screen();
2019-11-18 20:11:22 +03:00
let to_owned_hint = |t: &Exercise| t.hint.to_owned();
let failed_exercise_hint = match verify(exercises.iter(), verbose) {
Ok(_) => return Ok(()),
Err(exercise) => Arc::new(Mutex::new(Some(to_owned_hint(exercise)))),
};
2019-11-18 20:11:22 +03:00
spawn_watch_shell(&failed_exercise_hint);
loop {
2019-03-16 02:01:45 +03:00
match rx.recv() {
2019-01-09 22:33:58 +03:00
Ok(event) => match event {
2019-03-06 21:38:55 +03:00
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()
.skip_while(|e| !filepath.ends_with(&e.path));
clear_screen();
match verify(pending_exercises, verbose) {
Ok(_) => return Ok(()),
Err(exercise) => {
let mut failed_exercise_hint = failed_exercise_hint.lock().unwrap();
*failed_exercise_hint = Some(to_owned_hint(exercise));
}
}
2019-03-06 21:38:55 +03:00
}
}
2019-01-09 22:33:58 +03:00
_ => {}
},
Err(e) => println!("watch error: {:?}", e),
}
}
}
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)
}