2024-04-10 20:51:02 -04:00
|
|
|
use anyhow::Result;
|
2024-04-07 13:29:16 -04:00
|
|
|
use crossterm::{
|
2024-04-23 20:52:30 -04:00
|
|
|
style::{style, Stylize},
|
2024-04-29 19:41:08 -04:00
|
|
|
terminal::size,
|
2024-04-07 13:29:16 -04:00
|
|
|
};
|
2024-04-12 12:58:01 -04:00
|
|
|
use std::io::{self, StdoutLock, Write};
|
2024-04-07 13:29:16 -04:00
|
|
|
|
2024-04-12 09:27:29 -04:00
|
|
|
use crate::{
|
|
|
|
app_state::{AppState, ExercisesProgress},
|
2024-04-29 19:41:08 -04:00
|
|
|
clear_terminal,
|
2024-04-24 19:56:01 -04:00
|
|
|
exercise::OUTPUT_CAPACITY,
|
2024-04-12 09:27:29 -04:00
|
|
|
progress_bar::progress_bar,
|
2024-04-23 20:52:30 -04:00
|
|
|
terminal_link::TerminalFileLink,
|
2024-04-12 09:27:29 -04:00
|
|
|
};
|
2024-04-07 13:29:16 -04:00
|
|
|
|
2024-04-23 20:52:30 -04:00
|
|
|
enum DoneStatus {
|
|
|
|
DoneWithSolution(String),
|
|
|
|
DoneWithoutSolution,
|
|
|
|
Pending,
|
|
|
|
}
|
|
|
|
|
2024-04-07 13:29:16 -04:00
|
|
|
pub struct WatchState<'a> {
|
|
|
|
writer: StdoutLock<'a>,
|
2024-04-10 20:51:02 -04:00
|
|
|
app_state: &'a mut AppState,
|
2024-04-24 19:56:01 -04:00
|
|
|
output: Vec<u8>,
|
2024-04-11 20:45:54 -04:00
|
|
|
show_hint: bool,
|
2024-04-23 20:52:30 -04:00
|
|
|
done_status: DoneStatus,
|
2024-04-14 11:10:53 -04:00
|
|
|
manual_run: bool,
|
2024-04-07 13:29:16 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> WatchState<'a> {
|
2024-04-14 11:10:53 -04:00
|
|
|
pub fn new(app_state: &'a mut AppState, manual_run: bool) -> Self {
|
2024-04-07 13:29:16 -04:00
|
|
|
let writer = io::stdout().lock();
|
|
|
|
|
|
|
|
Self {
|
|
|
|
writer,
|
2024-04-10 20:51:02 -04:00
|
|
|
app_state,
|
2024-04-24 19:56:01 -04:00
|
|
|
output: Vec::with_capacity(OUTPUT_CAPACITY),
|
2024-04-11 20:45:54 -04:00
|
|
|
show_hint: false,
|
2024-04-23 20:52:30 -04:00
|
|
|
done_status: DoneStatus::Pending,
|
2024-04-14 11:10:53 -04:00
|
|
|
manual_run,
|
2024-04-07 13:29:16 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn into_writer(self) -> StdoutLock<'a> {
|
|
|
|
self.writer
|
|
|
|
}
|
|
|
|
|
2024-04-11 20:45:54 -04:00
|
|
|
pub fn run_current_exercise(&mut self) -> Result<()> {
|
|
|
|
self.show_hint = false;
|
|
|
|
|
2024-04-26 22:14:59 -04:00
|
|
|
let success = self
|
|
|
|
.app_state
|
|
|
|
.current_exercise()
|
|
|
|
.run(&mut self.output, self.app_state.target_dir())?;
|
2024-04-24 19:56:01 -04:00
|
|
|
if success {
|
2024-04-23 20:52:30 -04:00
|
|
|
self.done_status =
|
|
|
|
if let Some(solution_path) = self.app_state.current_solution_path()? {
|
|
|
|
DoneStatus::DoneWithSolution(solution_path)
|
|
|
|
} else {
|
|
|
|
DoneStatus::DoneWithoutSolution
|
|
|
|
};
|
2024-04-11 20:45:54 -04:00
|
|
|
} else {
|
2024-04-12 12:57:04 -04:00
|
|
|
self.app_state
|
|
|
|
.set_pending(self.app_state.current_exercise_ind())?;
|
|
|
|
|
2024-04-23 20:52:30 -04:00
|
|
|
self.done_status = DoneStatus::Pending;
|
2024-04-07 13:29:16 -04:00
|
|
|
}
|
|
|
|
|
2024-04-11 20:45:54 -04:00
|
|
|
self.render()
|
2024-04-07 13:29:16 -04:00
|
|
|
}
|
|
|
|
|
2024-04-11 20:45:54 -04:00
|
|
|
pub fn run_exercise_with_ind(&mut self, exercise_ind: usize) -> Result<()> {
|
2024-04-10 20:51:02 -04:00
|
|
|
self.app_state.set_current_exercise_ind(exercise_ind)?;
|
|
|
|
self.run_current_exercise()
|
2024-04-07 13:29:16 -04:00
|
|
|
}
|
|
|
|
|
2024-04-12 12:57:04 -04:00
|
|
|
pub fn next_exercise(&mut self) -> Result<ExercisesProgress> {
|
2024-04-23 20:52:30 -04:00
|
|
|
if matches!(self.done_status, DoneStatus::Pending) {
|
2024-04-12 09:27:29 -04:00
|
|
|
self.writer
|
|
|
|
.write_all(b"The current exercise isn't done yet\n")?;
|
|
|
|
self.show_prompt()?;
|
2024-04-12 12:57:04 -04:00
|
|
|
return Ok(ExercisesProgress::Pending);
|
2024-04-12 09:27:29 -04:00
|
|
|
}
|
|
|
|
|
2024-04-12 12:57:04 -04:00
|
|
|
self.app_state.done_current_exercise(&mut self.writer)
|
2024-04-12 09:27:29 -04:00
|
|
|
}
|
|
|
|
|
2024-04-10 20:51:02 -04:00
|
|
|
fn show_prompt(&mut self) -> io::Result<()> {
|
2024-04-11 20:45:54 -04:00
|
|
|
self.writer.write_all(b"\n")?;
|
2024-04-10 09:56:38 -04:00
|
|
|
|
2024-04-14 11:10:53 -04:00
|
|
|
if self.manual_run {
|
2024-04-24 20:03:26 -04:00
|
|
|
write!(self.writer, "{}un/", 'r'.bold())?;
|
2024-04-14 11:10:53 -04:00
|
|
|
}
|
|
|
|
|
2024-04-23 20:52:30 -04:00
|
|
|
if !matches!(self.done_status, DoneStatus::Pending) {
|
2024-04-24 20:03:26 -04:00
|
|
|
write!(self.writer, "{}ext/", 'n'.bold())?;
|
2024-04-12 09:27:29 -04:00
|
|
|
}
|
|
|
|
|
2024-04-11 20:45:54 -04:00
|
|
|
if !self.show_hint {
|
2024-04-24 20:03:26 -04:00
|
|
|
write!(self.writer, "{}int/", 'h'.bold())?;
|
2024-04-10 09:56:38 -04:00
|
|
|
}
|
|
|
|
|
2024-04-24 20:03:26 -04:00
|
|
|
write!(self.writer, "{}ist/{}uit? ", 'l'.bold(), 'q'.bold())?;
|
2024-04-10 09:56:38 -04:00
|
|
|
|
2024-04-07 13:29:16 -04:00
|
|
|
self.writer.flush()
|
|
|
|
}
|
|
|
|
|
2024-04-09 15:07:53 -04:00
|
|
|
pub fn render(&mut self) -> Result<()> {
|
2024-04-12 12:57:04 -04:00
|
|
|
// Prevent having the first line shifted.
|
2024-04-09 21:56:41 -04:00
|
|
|
self.writer.write_all(b"\n")?;
|
|
|
|
|
2024-04-29 19:41:08 -04:00
|
|
|
clear_terminal(&mut self.writer)?;
|
2024-04-07 13:29:16 -04:00
|
|
|
|
2024-04-24 19:56:01 -04:00
|
|
|
self.writer.write_all(&self.output)?;
|
2024-04-09 16:06:55 -04:00
|
|
|
self.writer.write_all(b"\n")?;
|
2024-04-10 09:56:38 -04:00
|
|
|
|
2024-04-11 20:45:54 -04:00
|
|
|
if self.show_hint {
|
2024-04-24 20:03:26 -04:00
|
|
|
writeln!(
|
|
|
|
self.writer,
|
|
|
|
"{}\n{}\n",
|
2024-04-12 12:57:04 -04:00
|
|
|
"Hint".bold().cyan().underlined(),
|
|
|
|
self.app_state.current_exercise().hint,
|
2024-04-24 20:03:26 -04:00
|
|
|
)?;
|
2024-04-10 09:56:38 -04:00
|
|
|
}
|
|
|
|
|
2024-04-23 20:52:30 -04:00
|
|
|
if !matches!(self.done_status, DoneStatus::Pending) {
|
2024-04-24 20:03:26 -04:00
|
|
|
writeln!(
|
|
|
|
self.writer,
|
|
|
|
"{}\n",
|
2024-04-11 20:45:54 -04:00
|
|
|
"Exercise done ✓
|
2024-04-27 17:38:26 -04:00
|
|
|
When you are done experimenting, enter `n` (or `next`) to move on to the next exercise 🦀"
|
2024-04-11 20:45:54 -04:00
|
|
|
.bold()
|
|
|
|
.green(),
|
2024-04-24 20:03:26 -04:00
|
|
|
)?;
|
2024-04-11 20:45:54 -04:00
|
|
|
}
|
|
|
|
|
2024-04-23 20:52:30 -04:00
|
|
|
if let DoneStatus::DoneWithSolution(solution_path) = &self.done_status {
|
2024-04-24 20:03:26 -04:00
|
|
|
writeln!(
|
|
|
|
self.writer,
|
|
|
|
"A solution file can be found at {}\n",
|
2024-04-23 20:52:30 -04:00
|
|
|
style(TerminalFileLink(solution_path)).underlined().green()
|
2024-04-24 20:03:26 -04:00
|
|
|
)?;
|
2024-04-23 20:52:30 -04:00
|
|
|
}
|
|
|
|
|
2024-04-09 15:07:53 -04:00
|
|
|
let line_width = size()?.0;
|
2024-04-10 20:51:02 -04:00
|
|
|
let progress_bar = progress_bar(
|
|
|
|
self.app_state.n_done(),
|
|
|
|
self.app_state.exercises().len() as u16,
|
|
|
|
line_width,
|
|
|
|
)?;
|
2024-04-24 20:03:26 -04:00
|
|
|
writeln!(
|
|
|
|
self.writer,
|
|
|
|
"{progress_bar}Current exercise: {}",
|
2024-04-13 20:41:19 -04:00
|
|
|
self.app_state.current_exercise().terminal_link(),
|
2024-04-24 20:03:26 -04:00
|
|
|
)?;
|
2024-04-10 08:29:31 -04:00
|
|
|
|
2024-04-09 15:07:53 -04:00
|
|
|
self.show_prompt()?;
|
|
|
|
|
|
|
|
Ok(())
|
2024-04-07 13:29:16 -04:00
|
|
|
}
|
|
|
|
|
2024-04-10 09:56:38 -04:00
|
|
|
pub fn show_hint(&mut self) -> Result<()> {
|
2024-04-11 20:45:54 -04:00
|
|
|
self.show_hint = true;
|
2024-04-10 09:56:38 -04:00
|
|
|
self.render()
|
2024-04-07 13:29:16 -04:00
|
|
|
}
|
|
|
|
|
2024-05-12 20:20:04 -04:00
|
|
|
pub fn handle_invalid_input(&mut self, input: char) -> io::Result<()> {
|
|
|
|
writeln!(
|
|
|
|
self.writer,
|
|
|
|
"Invalid input: {input} (confusing input can occur after resizing the terminal)",
|
|
|
|
)?;
|
2024-04-07 13:29:16 -04:00
|
|
|
self.show_prompt()
|
|
|
|
}
|
|
|
|
}
|