|
|
use crate::exercise::{Exercise, ExerciseList};
|
|
|
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 run;
|
|
|
mod verify;
|
|
|
|
|
|
// In sync with crate version
|
|
|
const VERSION: &str = "4.6.0";
|
|
|
|
|
|
#[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<Subcommands>,
|
|
|
}
|
|
|
|
|
|
#[derive(FromArgs, PartialEq, Debug)]
|
|
|
#[argh(subcommand)]
|
|
|
enum Subcommands {
|
|
|
Verify(VerifyArgs),
|
|
|
Watch(WatchArgs),
|
|
|
Run(RunArgs),
|
|
|
Hint(HintArgs),
|
|
|
List(ListArgs),
|
|
|
}
|
|
|
|
|
|
#[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 = "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<String>,
|
|
|
#[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!();
|
|
|
println!(r#" 欢迎来到... "#);
|
|
|
println!(r#" _ _ _ "#);
|
|
|
println!(r#" _ __ _ _ ___| |_| (_)_ __ __ _ ___ "#);
|
|
|
println!(r#" | '__| | | / __| __| | | '_ \ / _` / __| "#);
|
|
|
println!(r#" | | | |_| \__ \ |_| | | | | | (_| \__ \ "#);
|
|
|
println!(r#" |_| \__,_|___/\__|_|_|_| |_|\__, |___/ "#);
|
|
|
println!(r#" |___/ "#);
|
|
|
println!();
|
|
|
}
|
|
|
|
|
|
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 = args.nocapture;
|
|
|
|
|
|
let command = args.nested.unwrap_or_else(|| {
|
|
|
let text = fs::read_to_string("default_out.txt").unwrap();
|
|
|
println!("{}", text);
|
|
|
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, verbose).unwrap_or_else(|_| std::process::exit(1));
|
|
|
}
|
|
|
|
|
|
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!();
|
|
|
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!();
|
|
|
println!("We hope you enjoyed learning about the various aspects of Rust!");
|
|
|
println!(
|
|
|
"If you noticed any issues, please don't hesitate to report them to our repo."
|
|
|
);
|
|
|
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");
|
|
|
}
|
|
|
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<Mutex<Option<String>>>,
|
|
|
should_quit: Arc<AtomicBool>,
|
|
|
) {
|
|
|
let failed_exercise_hint = Arc::clone(failed_exercise_hint);
|
|
|
println!("欢迎使用 watch 模式！你可以输入 'help' 以查看你在这能够使用的命令概览");
|
|
|
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!("再见😊！");
|
|
|
} else if input.eq("help") {
|
|
|
println!("在 watch 模式下可使用的命令:");
|
|
|
println!(" hint - 显示当前练习的提示");
|
|
|
println!(" clear - 清理屏幕");
|
|
|
println!(" quit - 退出 watch 模式");
|
|
|
println!(" help - 显示这些帮助信息");
|
|
|
println!();
|
|
|
println!("当你编辑了练习文件的内容，watch 模式将自动重新评估当前练习");
|
|
|
} else {
|
|
|
println!("未知的命令: {}", input);
|
|
|
}
|
|
|
}
|
|
|
Err(error) => println!("命令读取错误: {}", 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<WatchStatus> {
|
|
|
/* 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(), 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()
|
|
|
.skip_while(|e| !filepath.ends_with(&e.path))
|
|
|
// .filter(|e| filepath.ends_with(&e.path))
|
|
|
.chain(
|
|
|
exercises
|
|
|
.iter()
|
|
|
.filter(|e| !e.looks_done() && !filepath.ends_with(&e.path)),
|
|
|
);
|
|
|
clear_screen();
|
|
|
match verify(pending_exercises, 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)
|
|
|
}
|
