summaryrefslogtreecommitdiff
path: root/src/exercise.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/exercise.rs')
-rw-r--r--src/exercise.rs485
1 files changed, 144 insertions, 341 deletions
diff --git a/src/exercise.rs b/src/exercise.rs
index 664b362..b6adc14 100644
--- a/src/exercise.rs
+++ b/src/exercise.rs
@@ -1,378 +1,181 @@
-use regex::Regex;
-use serde::Deserialize;
-use std::env;
-use std::fmt::{self, Display, Formatter};
-use std::fs::{self, remove_file, File};
-use std::io::Read;
-use std::path::PathBuf;
-use std::process::{self, Command};
-
-const RUSTC_COLOR_ARGS: &[&str] = &["--color", "always"];
-const RUSTC_EDITION_ARGS: &[&str] = &["--edition", "2021"];
-const RUSTC_NO_DEBUG_ARGS: &[&str] = &["-C", "strip=debuginfo"];
-const I_AM_DONE_REGEX: &str = r"(?m)^\s*///?\s*I\s+AM\s+NOT\s+DONE";
-const CONTEXT: usize = 2;
-const CLIPPY_CARGO_TOML_PATH: &str = "./exercises/22_clippy/Cargo.toml";
-
-// Get a temporary file name that is hopefully unique
-#[inline]
-fn temp_file() -> String {
- let thread_id: String = format!("{:?}", std::thread::current().id())
- .chars()
- .filter(|c| c.is_alphanumeric())
- .collect();
-
- format!("./temp_{}_{thread_id}", process::id())
-}
-
-// The mode of the exercise.
-#[derive(Deserialize, Copy, Clone, Debug)]
-#[serde(rename_all = "lowercase")]
-pub enum Mode {
- // Indicates that the exercise should be compiled as a binary
- Compile,
- // Indicates that the exercise should be compiled as a test harness
- Test,
- // Indicates that the exercise should be linted with clippy
- Clippy,
-}
+use anyhow::Result;
+use crossterm::style::{style, StyledContent, Stylize};
+use std::{
+ fmt::{self, Display, Formatter},
+ io::Write,
+ path::{Path, PathBuf},
+ process::Command,
+};
+
+use crate::{
+ cmd::{run_cmd, CargoCmd},
+ in_official_repo,
+ terminal_link::TerminalFileLink,
+ DEBUG_PROFILE,
+};
+
+/// The initial capacity of the output buffer.
+pub const OUTPUT_CAPACITY: usize = 1 << 14;
+
+// Run an exercise binary and append its output to the `output` buffer.
+// Compilation must be done before calling this method.
+fn run_bin(bin_name: &str, output: &mut Vec<u8>, target_dir: &Path) -> Result<bool> {
+ writeln!(output, "{}", "Output".underlined())?;
+
+ // 7 = "/debug/".len()
+ let mut bin_path = PathBuf::with_capacity(target_dir.as_os_str().len() + 7 + bin_name.len());
+ bin_path.push(target_dir);
+ bin_path.push("debug");
+ bin_path.push(bin_name);
+
+ let success = run_cmd(Command::new(&bin_path), &bin_path.to_string_lossy(), output)?;
+
+ if !success {
+ // This output is important to show the user that something went wrong.
+ // Otherwise, calling something like `exit(1)` in an exercise without further output
+ // leaves the user confused about why the exercise isn't done yet.
+ writeln!(
+ output,
+ "{}",
+ "The exercise didn't run successfully (nonzero exit code)"
+ .bold()
+ .red(),
+ )?;
+ }
-#[derive(Deserialize)]
-pub struct ExerciseList {
- pub exercises: Vec<Exercise>,
+ Ok(success)
}
-// A representation of a rustlings exercise.
-// This is deserialized from the accompanying info.toml file
-#[derive(Deserialize, Debug)]
+/// See `info_file::ExerciseInfo`
pub struct Exercise {
- // Name of the exercise
- pub name: String,
- // The path to the file containing the exercise's source code
- pub path: PathBuf,
- // The mode of the exercise (Test, Compile, or Clippy)
- pub mode: Mode,
- // The hint text associated with the exercise
+ pub dir: Option<&'static str>,
+ pub name: &'static str,
+ /// Path of the exercise file starting with the `exercises/` directory.
+ pub path: &'static str,
+ pub test: bool,
+ pub strict_clippy: bool,
pub hint: String,
+ pub done: bool,
}
-// An enum to track of the state of an Exercise.
-// An Exercise can be either Done or Pending
-#[derive(PartialEq, Debug)]
-pub enum State {
- // The state of the exercise once it's been completed
- Done,
- // The state of the exercise while it's not completed yet
- Pending(Vec<ContextLine>),
-}
-
-// The context information of a pending exercise
-#[derive(PartialEq, Debug)]
-pub struct ContextLine {
- // The source code that is still pending completion
- pub line: String,
- // The line number of the source code still pending completion
- pub number: usize,
- // Whether or not this is important
- pub important: bool,
-}
-
-// The result of compiling an exercise
-pub struct CompiledExercise<'a> {
- exercise: &'a Exercise,
- _handle: FileHandle,
-}
-
-impl<'a> CompiledExercise<'a> {
- // Run the compiled exercise
- pub fn run(&self) -> Result<ExerciseOutput, ExerciseOutput> {
- self.exercise.run()
+impl Exercise {
+ pub fn terminal_link(&self) -> StyledContent<TerminalFileLink<'_>> {
+ style(TerminalFileLink(self.path)).underlined().blue()
}
}
-// A representation of an already executed binary
-#[derive(Debug)]
-pub struct ExerciseOutput {
- // The textual contents of the standard output of the binary
- pub stdout: String,
- // The textual contents of the standard error of the binary
- pub stderr: String,
-}
-
-struct FileHandle;
-
-impl Drop for FileHandle {
- fn drop(&mut self) {
- clean();
+impl Display for Exercise {
+ fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+ self.path.fmt(f)
}
}
-impl Exercise {
- pub fn compile(&self) -> Result<CompiledExercise, ExerciseOutput> {
- let cmd = match self.mode {
- Mode::Compile => Command::new("rustc")
- .args([self.path.to_str().unwrap(), "-o", &temp_file()])
- .args(RUSTC_COLOR_ARGS)
- .args(RUSTC_EDITION_ARGS)
- .args(RUSTC_NO_DEBUG_ARGS)
- .output(),
- Mode::Test => Command::new("rustc")
- .args(["--test", self.path.to_str().unwrap(), "-o", &temp_file()])
- .args(RUSTC_COLOR_ARGS)
- .args(RUSTC_EDITION_ARGS)
- .args(RUSTC_NO_DEBUG_ARGS)
- .output(),
- Mode::Clippy => {
- let cargo_toml = format!(
- r#"[package]
-name = "{}"
-version = "0.0.1"
-edition = "2021"
-[[bin]]
-name = "{}"
-path = "{}.rs""#,
- self.name, self.name, self.name
- );
- let cargo_toml_error_msg = if env::var("NO_EMOJI").is_ok() {
- "Failed to write Clippy Cargo.toml file."
- } else {
- "Failed to write 📎 Clippy 📎 Cargo.toml file."
- };
- fs::write(CLIPPY_CARGO_TOML_PATH, cargo_toml).expect(cargo_toml_error_msg);
- // To support the ability to run the clippy exercises, build
- // an executable, in addition to running clippy. With a
- // compilation failure, this would silently fail. But we expect
- // clippy to reflect the same failure while compiling later.
- Command::new("rustc")
- .args([self.path.to_str().unwrap(), "-o", &temp_file()])
- .args(RUSTC_COLOR_ARGS)
- .args(RUSTC_EDITION_ARGS)
- .args(RUSTC_NO_DEBUG_ARGS)
- .output()
- .expect("Failed to compile!");
- // Due to an issue with Clippy, a cargo clean is required to catch all lints.
- // See https://github.com/rust-lang/rust-clippy/issues/2604
- // This is already fixed on Clippy's master branch. See this issue to track merging into Cargo:
- // https://github.com/rust-lang/rust-clippy/issues/3837
- Command::new("cargo")
- .args(["clean", "--manifest-path", CLIPPY_CARGO_TOML_PATH])
- .args(RUSTC_COLOR_ARGS)
- .output()
- .expect("Failed to run 'cargo clean'");
- Command::new("cargo")
- .args(["clippy", "--manifest-path", CLIPPY_CARGO_TOML_PATH])
- .args(RUSTC_COLOR_ARGS)
- .args(["--", "-D", "warnings", "-D", "clippy::float_cmp"])
- .output()
- }
+pub trait RunnableExercise {
+ fn name(&self) -> &str;
+ fn strict_clippy(&self) -> bool;
+ fn test(&self) -> bool;
+
+ // Compile, check and run the exercise or its solution (depending on `bin_name´).
+ // The output is written to the `output` buffer after clearing it.
+ fn run(&self, bin_name: &str, output: &mut Vec<u8>, target_dir: &Path) -> Result<bool> {
+ output.clear();
+
+ // Developing the official Rustlings.
+ let dev = DEBUG_PROFILE && in_official_repo();
+
+ let build_success = CargoCmd {
+ subcommand: "build",
+ args: &[],
+ bin_name,
+ description: "cargo build …",
+ hide_warnings: false,
+ target_dir,
+ output,
+ dev,
}
- .expect("Failed to run 'compile' command.");
-
- if cmd.status.success() {
- Ok(CompiledExercise {
- exercise: self,
- _handle: FileHandle,
- })
- } else {
- clean();
- Err(ExerciseOutput {
- stdout: String::from_utf8_lossy(&cmd.stdout).to_string(),
- stderr: String::from_utf8_lossy(&cmd.stderr).to_string(),
- })
+ .run()?;
+ if !build_success {
+ return Ok(false);
}
- }
-
- fn run(&self) -> Result<ExerciseOutput, ExerciseOutput> {
- let arg = match self.mode {
- Mode::Test => "--show-output",
- _ => "",
- };
- let cmd = Command::new(temp_file())
- .arg(arg)
- .output()
- .expect("Failed to run 'run' command");
- let output = ExerciseOutput {
- stdout: String::from_utf8_lossy(&cmd.stdout).to_string(),
- stderr: String::from_utf8_lossy(&cmd.stderr).to_string(),
- };
+ // Discard the output of `cargo build` because it will be shown again by Clippy.
+ output.clear();
- if cmd.status.success() {
- Ok(output)
+ // `--profile test` is required to also check code with `[cfg(test)]`.
+ let clippy_args: &[&str] = if self.strict_clippy() {
+ &["--profile", "test", "--", "-D", "warnings"]
} else {
- Err(output)
- }
- }
-
- pub fn state(&self) -> State {
- let mut source_file = File::open(&self.path).unwrap_or_else(|e| {
- panic!(
- "We were unable to open the exercise file {}! {e}",
- self.path.display()
- )
- });
-
- let source = {
- let mut s = String::new();
- source_file.read_to_string(&mut s).unwrap_or_else(|e| {
- panic!(
- "We were unable to read the exercise file {}! {e}",
- self.path.display()
- )
- });
- s
+ &["--profile", "test"]
};
-
- let re = Regex::new(I_AM_DONE_REGEX).unwrap();
-
- if !re.is_match(&source) {
- return State::Done;
+ let clippy_success = CargoCmd {
+ subcommand: "clippy",
+ args: clippy_args,
+ bin_name,
+ description: "cargo clippy …",
+ hide_warnings: false,
+ target_dir,
+ output,
+ dev,
+ }
+ .run()?;
+ if !clippy_success {
+ return Ok(false);
}
- let matched_line_index = source
- .lines()
- .enumerate()
- .find_map(|(i, line)| if re.is_match(line) { Some(i) } else { None })
- .expect("This should not happen at all");
-
- let min_line = ((matched_line_index as i32) - (CONTEXT as i32)).max(0) as usize;
- let max_line = matched_line_index + CONTEXT;
+ if !self.test() {
+ return run_bin(bin_name, output, target_dir);
+ }
- let context = source
- .lines()
- .enumerate()
- .filter(|&(i, _)| i >= min_line && i <= max_line)
- .map(|(i, line)| ContextLine {
- line: line.to_string(),
- number: i + 1,
- important: i == matched_line_index,
- })
- .collect();
+ let test_success = CargoCmd {
+ subcommand: "test",
+ args: &["--", "--color", "always", "--show-output"],
+ bin_name,
+ description: "cargo test …",
+ // Hide warnings because they are shown by Clippy.
+ hide_warnings: true,
+ target_dir,
+ output,
+ dev,
+ }
+ .run()?;
- State::Pending(context)
- }
+ let run_success = run_bin(bin_name, output, target_dir)?;
- // Check that the exercise looks to be solved using self.state()
- // This is not the best way to check since
- // the user can just remove the "I AM NOT DONE" string from the file
- // without actually having solved anything.
- // The only other way to truly check this would to compile and run
- // the exercise; which would be both costly and counterintuitive
- pub fn looks_done(&self) -> bool {
- self.state() == State::Done
+ Ok(test_success && run_success)
}
-}
-impl Display for Exercise {
- fn fmt(&self, f: &mut Formatter) -> fmt::Result {
- write!(f, "{}", self.path.to_str().unwrap())
+ /// Compile, check and run the exercise.
+ /// The output is written to the `output` buffer after clearing it.
+ #[inline]
+ fn run_exercise(&self, output: &mut Vec<u8>, target_dir: &Path) -> Result<bool> {
+ self.run(self.name(), output, target_dir)
}
-}
-
-#[inline]
-fn clean() {
- let _ignored = remove_file(temp_file());
-}
-#[cfg(test)]
-mod test {
- use super::*;
- use std::path::Path;
+ /// Compile, check and run the exercise's solution.
+ /// The output is written to the `output` buffer after clearing it.
+ fn run_solution(&self, output: &mut Vec<u8>, target_dir: &Path) -> Result<bool> {
+ let name = self.name();
+ let mut bin_name = String::with_capacity(name.len());
+ bin_name.push_str(name);
+ bin_name.push_str("_sol");
- #[test]
- fn test_clean() {
- File::create(temp_file()).unwrap();
- let exercise = Exercise {
- name: String::from("example"),
- path: PathBuf::from("tests/fixture/state/pending_exercise.rs"),
- mode: Mode::Compile,
- hint: String::from(""),
- };
- let compiled = exercise.compile().unwrap();
- drop(compiled);
- assert!(!Path::new(&temp_file()).exists());
+ self.run(&bin_name, output, target_dir)
}
+}
- #[test]
- #[cfg(target_os = "windows")]
- fn test_no_pdb_file() {
- [Mode::Compile, Mode::Test] // Clippy doesn't like to test
- .iter()
- .for_each(|mode| {
- let exercise = Exercise {
- name: String::from("example"),
- // We want a file that does actually compile
- path: PathBuf::from("tests/fixture/state/pending_exercise.rs"),
- mode: *mode,
- hint: String::from(""),
- };
- let _ = exercise.compile().unwrap();
- assert!(!Path::new(&format!("{}.pdb", temp_file())).exists());
- });
- }
-
- #[test]
- fn test_pending_state() {
- let exercise = Exercise {
- name: "pending_exercise".into(),
- path: PathBuf::from("tests/fixture/state/pending_exercise.rs"),
- mode: Mode::Compile,
- hint: String::new(),
- };
-
- let state = exercise.state();
- let expected = vec![
- ContextLine {
- line: "// fake_exercise".to_string(),
- number: 1,
- important: false,
- },
- ContextLine {
- line: "".to_string(),
- number: 2,
- important: false,
- },
- ContextLine {
- line: "// I AM NOT DONE".to_string(),
- number: 3,
- important: true,
- },
- ContextLine {
- line: "".to_string(),
- number: 4,
- important: false,
- },
- ContextLine {
- line: "fn main() {".to_string(),
- number: 5,
- important: false,
- },
- ];
-
- assert_eq!(state, State::Pending(expected));
+impl RunnableExercise for Exercise {
+ #[inline]
+ fn name(&self) -> &str {
+ self.name
}
- #[test]
- fn test_finished_exercise() {
- let exercise = Exercise {
- name: "finished_exercise".into(),
- path: PathBuf::from("tests/fixture/state/finished_exercise.rs"),
- mode: Mode::Compile,
- hint: String::new(),
- };
-
- assert_eq!(exercise.state(), State::Done);
+ #[inline]
+ fn strict_clippy(&self) -> bool {
+ self.strict_clippy
}
- #[test]
- fn test_exercise_with_output() {
- let exercise = Exercise {
- name: "exercise_with_output".into(),
- path: PathBuf::from("tests/fixture/success/testSuccess.rs"),
- mode: Mode::Test,
- hint: String::new(),
- };
- let out = exercise.compile().unwrap().run().unwrap();
- assert!(out.stdout.contains("THIS TEST TOO SHALL PASS"));
+ #[inline]
+ fn test(&self) -> bool {
+ self.test
}
}
generated by cgit v1.2.3 (git 2.46.0) at 2026-04-07 03:31:10 +0000