rustlings/src/main.rs

228 lines
7.3 KiB
Rust
Raw Normal View History

2024-04-05 04:04:53 +03:00
use crate::consts::{DEFAULT_OUT, WELCOME};
2024-03-31 21:08:23 +03:00
use crate::embedded::{WriteStrategy, EMBEDDED_FILES};
2022-08-18 13:47:26 +03:00
use crate::exercise::{Exercise, ExerciseList};
2024-03-31 21:08:23 +03:00
use crate::run::run;
2024-04-05 04:04:53 +03:00
use crate::tui::tui;
2019-01-09 22:33:58 +03:00
use crate::verify::verify;
2024-04-01 19:38:01 +03:00
use anyhow::{bail, Context, Result};
2023-08-26 00:18:01 +03:00
use clap::{Parser, Subcommand};
2024-04-05 04:04:53 +03:00
use std::io::Write;
use std::path::Path;
2024-04-04 22:06:11 +03:00
use std::process::exit;
2024-04-01 19:38:01 +03:00
use verify::VerifyState;
2019-01-09 22:33:43 +03:00
2024-04-05 04:04:53 +03:00
mod consts;
2024-03-28 23:06:36 +03:00
mod embedded;
mod exercise;
mod init;
2019-01-09 22:33:43 +03:00
mod run;
2024-04-05 04:04:53 +03:00
mod tui;
2019-01-09 22:33:58 +03:00
mod verify;
2018-05-14 19:41:58 +03:00
/// Rustlings is a collection of small exercises to get you used to writing and reading Rust code
2023-08-26 00:18:01 +03:00
#[derive(Parser)]
#[command(version)]
struct Args {
2023-08-26 00:18:01 +03:00
#[command(subcommand)]
command: Option<Subcommands>,
}
2023-08-26 00:18:01 +03:00
#[derive(Subcommand)]
enum Subcommands {
/// Initialize Rustlings
Init,
2023-08-26 00:18:01 +03:00
/// Verify all exercises according to the recommended order
Verify,
2024-04-05 04:04:53 +03:00
/// Same as just running `rustlings` without a subcommand.
2024-04-04 22:06:11 +03:00
Watch,
2023-08-26 00:18:01 +03:00
/// Run/Test a single exercise
Run {
/// The name of the exercise
name: String,
},
2024-03-29 00:11:16 +03:00
/// Reset a single exercise
2023-08-26 00:18:01 +03:00
Reset {
/// The name of the exercise
name: String,
},
/// Return a hint for the given exercise
Hint {
/// The name of the exercise
name: String,
},
/// List the exercises available in Rustlings
List {
/// Show only the paths of the exercises
#[arg(short, long)]
paths: bool,
/// Show only the names of the exercises
#[arg(short, long)]
names: bool,
/// Provide a string to match exercise names.
/// Comma separated patterns are accepted
#[arg(short, long)]
filter: Option<String>,
/// Display only exercises not yet solved
#[arg(short, long)]
unsolved: bool,
/// Display only exercises that have been solved
#[arg(short, long)]
solved: bool,
},
}
2024-03-25 05:46:56 +03:00
fn main() -> Result<()> {
2023-08-26 00:18:01 +03:00
let args = Args::parse();
2023-08-26 00:18:01 +03:00
if args.command.is_none() {
println!("\n{WELCOME}\n");
2019-01-09 22:44:55 +03:00
}
2018-11-14 22:12:20 +03:00
2024-03-31 19:25:54 +03:00
which::which("cargo").context(
"Failed to find `cargo`.
2024-03-31 17:55:33 +03:00
Did you already install Rust?
2024-03-31 19:25:54 +03:00
Try running `cargo --version` to diagnose the problem.",
)?;
2024-03-31 17:55:33 +03:00
let exercises = ExerciseList::parse()?.exercises;
if matches!(args.command, Some(Subcommands::Init)) {
init::init_rustlings(&exercises).context("Initialization failed")?;
2024-03-29 03:52:05 +03:00
println!(
"\nDone initialization!\n
Run `cd rustlings` to go into the generated directory.
Then run `rustlings` for further instructions on getting started."
);
return Ok(());
} else if !Path::new("exercises").is_dir() {
println!(
"\nThe `exercises` directory wasn't found in the current directory.
2024-03-29 03:52:05 +03:00
If you are just starting with Rustlings, run the command `rustlings init` to initialize it."
);
exit(1);
}
2024-04-05 04:04:53 +03:00
match args.command {
None | Some(Subcommands::Watch) => {
println!("{DEFAULT_OUT}\n");
tui(&exercises)?;
}
// `Init` is handled above.
2024-04-05 04:04:53 +03:00
Some(Subcommands::Init) => (),
Some(Subcommands::List {
2023-08-26 00:18:01 +03:00
paths,
names,
filter,
unsolved,
solved,
2024-04-05 04:04:53 +03:00
}) => {
2023-08-26 00:18:01 +03:00
if !paths && !names {
println!("{:<17}\t{:<46}\t{:<7}", "Name", "Path", "Status");
}
let mut exercises_done: u16 = 0;
2024-03-23 23:56:40 +03:00
let lowercase_filter = filter
.as_ref()
.map(|s| s.to_lowercase())
.unwrap_or_default();
let filters = lowercase_filter
.split(',')
.filter_map(|f| {
let f = f.trim();
if f.is_empty() {
None
} else {
Some(f)
}
})
.collect::<Vec<_>>();
for exercise in &exercises {
2024-03-24 20:47:27 +03:00
let fname = exercise.path.to_string_lossy();
let filter_cond = filters
2024-03-23 23:56:40 +03:00
.iter()
.any(|f| exercise.name.contains(f) || fname.contains(f));
2024-03-31 19:25:54 +03:00
let looks_done = exercise.looks_done()?;
2024-03-24 20:50:46 +03:00
let status = if looks_done {
exercises_done += 1;
"Done"
} else {
"Pending"
};
2024-03-24 20:50:46 +03:00
let solve_cond =
(looks_done && solved) || (!looks_done && unsolved) || (!solved && !unsolved);
2023-08-26 00:18:01 +03:00
if solve_cond && (filter_cond || filter.is_none()) {
let line = if paths {
format!("{fname}\n")
2023-08-26 00:18:01 +03:00
} else if names {
2024-03-23 23:56:40 +03:00
format!("{}\n", exercise.name)
} else {
2024-03-23 23:56:40 +03:00
format!("{:<17}\t{fname:<46}\t{status:<7}\n", exercise.name)
};
// 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() {
2024-03-31 19:25:54 +03:00
std::io::ErrorKind::BrokenPipe => exit(0),
_ => exit(1),
};
});
}
}
2024-03-23 23:56:40 +03:00
}
let percentage_progress = exercises_done as f32 / exercises.len() as f32 * 100.0;
println!(
"Progress: You completed {} / {} exercises ({:.1} %).",
exercises_done,
exercises.len(),
percentage_progress
);
2024-03-31 19:25:54 +03:00
exit(0);
}
2024-04-05 04:04:53 +03:00
Some(Subcommands::Run { name }) => {
2024-03-31 19:25:54 +03:00
let exercise = find_exercise(&name, &exercises)?;
2024-04-04 22:06:11 +03:00
run(exercise).unwrap_or_else(|_| exit(1));
}
2024-04-05 04:04:53 +03:00
Some(Subcommands::Reset { name }) => {
2024-03-31 19:25:54 +03:00
let exercise = find_exercise(&name, &exercises)?;
2024-03-31 21:08:23 +03:00
EMBEDDED_FILES
.write_exercise_to_disk(&exercise.path, WriteStrategy::Overwrite)
.with_context(|| format!("Failed to reset the exercise {exercise}"))?;
2024-03-30 23:13:28 +03:00
println!("The file {} has been reset!", exercise.path.display());
}
2024-04-05 04:04:53 +03:00
Some(Subcommands::Hint { name }) => {
2024-03-31 19:25:54 +03:00
let exercise = find_exercise(&name, &exercises)?;
println!("{}", exercise.hint);
}
2024-04-05 04:04:53 +03:00
Some(Subcommands::Verify) => match verify(&exercises, (0, exercises.len()))? {
2024-04-01 19:38:01 +03:00
VerifyState::AllExercisesDone => println!("All exercises done!"),
VerifyState::Failed(exercise) => bail!("Exercise {exercise} failed"),
},
}
2024-03-25 05:46:56 +03:00
Ok(())
2018-05-06 19:59:50 +03:00
}
2024-03-31 19:25:54 +03:00
fn find_exercise<'a>(name: &str, exercises: &'a [Exercise]) -> Result<&'a Exercise> {
2024-03-26 19:49:55 +03:00
if name == "next" {
2024-03-31 19:25:54 +03:00
for exercise in exercises {
if !exercise.looks_done()? {
return Ok(exercise);
}
}
println!("🎉 Congratulations! You have done all the exercises!");
println!("🔚 There are no more exercises to do next!");
exit(0);
}
2024-03-31 19:25:54 +03:00
exercises
.iter()
.find(|e| e.name == name)
.with_context(|| format!("No exercise found for '{name}'!"))
}