2019-04-11 22:41:24 +02:00
|
|
|
use crate::exercise::{Exercise, ExerciseList};
|
2019-01-09 21:33:58 +02:00
|
|
|
use crate::run::run;
|
|
|
|
use crate::verify::verify;
|
|
|
|
use clap::{crate_version, App, Arg, SubCommand};
|
|
|
|
use notify::DebouncedEvent;
|
|
|
|
use notify::{RecommendedWatcher, RecursiveMode, Watcher};
|
2019-03-06 20:38:55 +02:00
|
|
|
use std::ffi::OsStr;
|
2019-04-11 22:41:24 +02:00
|
|
|
use std::fs;
|
2019-11-18 19:11:22 +02:00
|
|
|
use std::io;
|
2019-03-17 04:15:09 +02:00
|
|
|
use std::path::Path;
|
2019-11-11 18:15:14 +02:00
|
|
|
use std::process::{Command, Stdio};
|
2018-11-26 13:41:39 +02:00
|
|
|
use std::sync::mpsc::channel;
|
2019-11-18 19:11:22 +02:00
|
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use std::thread;
|
2018-11-26 13:41:39 +02:00
|
|
|
use std::time::Duration;
|
2019-01-09 21:33:43 +02:00
|
|
|
|
2019-04-11 22:41:24 +02:00
|
|
|
mod exercise;
|
2019-01-09 21:33:43 +02:00
|
|
|
mod run;
|
2019-01-09 21:33:58 +02:00
|
|
|
mod verify;
|
2018-05-14 18:41:58 +02:00
|
|
|
|
2018-11-09 21:31:14 +02:00
|
|
|
fn main() {
|
2018-11-26 12:10:38 +02:00
|
|
|
let matches = App::new("rustlings")
|
2018-11-14 21:12:20 +02:00
|
|
|
.version(crate_version!())
|
2019-01-23 22:43:32 +02:00
|
|
|
.author("Olivia Hugger, Carol Nichols")
|
|
|
|
.about("Rustlings is a collection of small exercises to get you used to writing and reading Rust code")
|
|
|
|
.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 16:18:43 +02:00
|
|
|
.subcommand(
|
|
|
|
SubCommand::with_name("run")
|
|
|
|
.alias("r")
|
2019-01-23 22:43:32 +02:00
|
|
|
.about("Runs/Tests a single exercise")
|
2019-11-11 16:46:32 +02:00
|
|
|
.arg(Arg::with_name("name").required(true).index(1)),
|
2019-01-09 21:33:58 +02:00
|
|
|
)
|
2019-11-11 17:51:38 +02: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)),
|
|
|
|
)
|
2019-01-09 21:33:58 +02:00
|
|
|
.get_matches();
|
2018-11-14 21:12:20 +02:00
|
|
|
|
2019-01-09 21:44:55 +02:00
|
|
|
if None == matches.subcommand_name() {
|
2019-03-11 16:09:20 +02:00
|
|
|
println!();
|
2019-01-09 21:44:55 +02:00
|
|
|
println!(r#" welcome to... "#);
|
|
|
|
println!(r#" _ _ _ "#);
|
|
|
|
println!(r#" _ __ _ _ ___| |_| (_)_ __ __ _ ___ "#);
|
|
|
|
println!(r#" | '__| | | / __| __| | | '_ \ / _` / __| "#);
|
|
|
|
println!(r#" | | | |_| \__ \ |_| | | | | | (_| \__ \ "#);
|
|
|
|
println!(r#" |_| \__,_|___/\__|_|_|_| |_|\__, |___/ "#);
|
|
|
|
println!(r#" |___/ "#);
|
2019-03-11 16:09:20 +02:00
|
|
|
println!();
|
2019-01-09 21:44:55 +02:00
|
|
|
}
|
2018-11-14 21:12:20 +02:00
|
|
|
|
2019-03-17 04:15:09 +02:00
|
|
|
if !Path::new("info.toml").exists() {
|
|
|
|
println!(
|
|
|
|
"{} must be run from the rustlings directory",
|
|
|
|
std::env::current_exe().unwrap().to_str().unwrap()
|
|
|
|
);
|
2019-04-22 12:43:39 +02:00
|
|
|
println!("Try `cd rustlings/`!");
|
2019-03-17 04:15:09 +02:00
|
|
|
std::process::exit(1);
|
|
|
|
}
|
|
|
|
|
2019-11-11 18:15:14 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2019-04-11 22:41:24 +02:00
|
|
|
let toml_str = &fs::read_to_string("info.toml").unwrap();
|
|
|
|
let exercises = toml::from_str::<ExerciseList>(toml_str).unwrap().exercises;
|
|
|
|
|
|
|
|
if let Some(ref matches) = matches.subcommand_matches("run") {
|
2019-11-11 18:47:45 +02:00
|
|
|
let name = matches.value_of("name").unwrap();
|
2019-04-11 22:41:24 +02:00
|
|
|
|
2019-11-11 18:19:50 +02:00
|
|
|
let matching_exercise = |e: &&Exercise| name == e.name;
|
2019-04-12 23:24:13 +02:00
|
|
|
|
|
|
|
let exercise = exercises.iter().find(matching_exercise).unwrap_or_else(|| {
|
2019-11-11 16:46:32 +02:00
|
|
|
println!("No exercise found for your given name!");
|
2019-04-12 23:24:13 +02:00
|
|
|
std::process::exit(1)
|
|
|
|
});
|
2019-04-11 22:41:24 +02:00
|
|
|
|
|
|
|
run(&exercise).unwrap_or_else(|_| std::process::exit(1));
|
2018-11-23 16:18:43 +02:00
|
|
|
}
|
|
|
|
|
2019-11-11 17:51:38 +02:00
|
|
|
if let Some(ref matches) = matches.subcommand_matches("hint") {
|
2019-11-11 18:47:45 +02:00
|
|
|
let name = matches.value_of("name").unwrap();
|
2019-11-11 17:51:38 +02:00
|
|
|
|
2019-11-11 18:19:50 +02: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)
|
|
|
|
});
|
2019-11-11 17:51:38 +02:00
|
|
|
|
|
|
|
println!("{}", exercise.hint);
|
|
|
|
}
|
|
|
|
|
2019-03-11 16:09:20 +02:00
|
|
|
if matches.subcommand_matches("verify").is_some() {
|
2019-04-11 22:41:24 +02:00
|
|
|
verify(&exercises).unwrap_or_else(|_| std::process::exit(1));
|
2018-11-26 13:41:39 +02:00
|
|
|
}
|
|
|
|
|
2019-03-11 16:09:20 +02:00
|
|
|
if matches.subcommand_matches("watch").is_some() {
|
2019-04-11 22:41:24 +02:00
|
|
|
watch(&exercises).unwrap();
|
2018-11-14 21:12:20 +02:00
|
|
|
}
|
2018-11-26 12:10:38 +02:00
|
|
|
|
2019-03-11 16:09:20 +02:00
|
|
|
if matches.subcommand_name().is_none() {
|
2019-06-05 12:18:50 +02:00
|
|
|
let text = fs::read_to_string("default_out.txt").unwrap();
|
|
|
|
println!("{}", text);
|
2018-11-26 12:10:38 +02:00
|
|
|
}
|
2018-05-06 18:59:50 +02:00
|
|
|
}
|
|
|
|
|
2019-11-18 19:11:22 +02: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");
|
|
|
|
thread::spawn(move || loop {
|
|
|
|
let mut input = String::new();
|
|
|
|
match io::stdin().read_line(&mut input) {
|
|
|
|
Ok(_) => {
|
|
|
|
if input.trim().eq("hint") {
|
|
|
|
if let Some(hint) = &*failed_exercise_hint.lock().unwrap() {
|
|
|
|
println!("{}", hint);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
println!("unknown command: {}", input);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(error) => println!("error reading command: {}", error),
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-04-11 22:41:24 +02:00
|
|
|
fn watch(exercises: &[Exercise]) -> notify::Result<()> {
|
2019-11-09 16:24:24 +02:00
|
|
|
/* Clears the terminal with an ANSI escape code.
|
|
|
|
Works in UNIX and newer Windows terminals. */
|
|
|
|
fn clear_screen() {
|
|
|
|
println!("\x1Bc");
|
|
|
|
}
|
|
|
|
|
2018-11-26 13:41:39 +02:00
|
|
|
let (tx, rx) = channel();
|
|
|
|
|
|
|
|
let mut watcher: RecommendedWatcher = Watcher::new(tx, Duration::from_secs(2))?;
|
2019-03-27 11:58:56 +02:00
|
|
|
watcher.watch(Path::new("./exercises"), RecursiveMode::Recursive)?;
|
2018-11-26 13:41:39 +02:00
|
|
|
|
2019-11-09 16:24:24 +02:00
|
|
|
clear_screen();
|
2019-11-18 19:11:22 +02:00
|
|
|
let verify_result = verify(exercises.iter());
|
2018-11-26 13:41:39 +02:00
|
|
|
|
2019-11-18 19:11:22 +02:00
|
|
|
let to_owned_hint = |t: &Exercise| t.hint.to_owned();
|
|
|
|
let failed_exercise_hint = Arc::new(Mutex::new(verify_result.map_err(to_owned_hint).err()));
|
|
|
|
spawn_watch_shell(&failed_exercise_hint);
|
2018-11-26 13:41:39 +02:00
|
|
|
loop {
|
2019-03-16 01:01:45 +02:00
|
|
|
match rx.recv() {
|
2019-01-09 21:33:58 +02:00
|
|
|
Ok(event) => match event {
|
2019-03-06 20:38:55 +02:00
|
|
|
DebouncedEvent::Create(b) | DebouncedEvent::Chmod(b) | DebouncedEvent::Write(b) => {
|
2019-07-11 23:54:18 +02:00
|
|
|
if b.extension() == Some(OsStr::new("rs")) && b.exists() {
|
2019-04-11 22:41:24 +02:00
|
|
|
let filepath = b.as_path().canonicalize().unwrap();
|
2019-11-11 14:38:24 +02:00
|
|
|
let pending_exercises = exercises
|
2019-04-11 22:41:24 +02:00
|
|
|
.iter()
|
|
|
|
.skip_while(|e| !filepath.ends_with(&e.path));
|
2019-11-09 16:24:24 +02:00
|
|
|
clear_screen();
|
2019-11-18 19:11:22 +02:00
|
|
|
let verify_result = verify(pending_exercises);
|
|
|
|
let mut failed_exercise_hint = failed_exercise_hint.lock().unwrap();
|
|
|
|
*failed_exercise_hint = verify_result.map_err(to_owned_hint).err();
|
2019-03-06 20:38:55 +02:00
|
|
|
}
|
2018-11-26 13:41:39 +02:00
|
|
|
}
|
2019-01-09 21:33:58 +02:00
|
|
|
_ => {}
|
2018-11-26 13:41:39 +02:00
|
|
|
},
|
|
|
|
Err(e) => println!("watch error: {:?}", e),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-11-11 18:15:14 +02:00
|
|
|
|
|
|
|
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)
|
|
|
|
}
|