feature: makes "compile" exercise print output, resolves #270

When running "compile"-mode exercises in interactive `verify` mode,
we print their output when we prompt the learner if they want to
continue. This improves the "experimentation" experience, since
trying different things does produce a visible change.

exercises/primitive_types/primitive_types4.rs

@@ -8,7 +8,4 @@
 fn slice_out_of_array() {
     let a = [1, 2, 3, 4, 5];
 
-    let nice_slice = ???
-
-    assert_eq!([2, 3, 4], nice_slice)
 }

src/verify.rs

@@ -1,12 +1,12 @@
-use crate::exercise::{Exercise, Mode, State};
+use crate::exercise::{CompiledExercise, Exercise, Mode, State};
 use console::style;
 use indicatif::ProgressBar;
 
 pub fn verify<'a>(start_at: impl IntoIterator<Item = &'a Exercise>) -> Result<(), &'a Exercise> {
     for exercise in start_at {
         let compile_result = match exercise.mode {
             Mode::Test => compile_and_test(&exercise, RunMode::Interactive),
-            Mode::Compile => compile_only(&exercise),
+            Mode::Compile => compile_and_run_interactively(&exercise),
             Mode::Clippy => compile_only(&exercise),
         };
         if !compile_result.unwrap_or(false) {
@@ -30,52 +30,53 @@ fn compile_only(exercise: &Exercise) -> Result<bool, ()> {
     let progress_bar = ProgressBar::new_spinner();
     progress_bar.set_message(format!("Compiling {}...", exercise).as_str());
     progress_bar.enable_steady_tick(100);
-    let compilation_result = exercise.compile();
+
+    let _ = compile(&exercise, &progress_bar)?;
     progress_bar.finish_and_clear();
 
-    match compilation_result {
-        Ok(_) => {
-            success!("Successfully compiled {}!", exercise);
-            Ok(prompt_for_completion(&exercise))
-        }
-        Err(output) => {
-            warn!(
-                "Compilation of {} failed! Compiler error message:\n",
-                exercise
-            );
-            println!("{}", output.stderr);
-            Err(())
-        }
-    }
+    success!("Successfully compiled {}!", exercise);
+    Ok(prompt_for_completion(&exercise, None))
 }
 
-fn compile_and_test(exercise: &Exercise, run_mode: RunMode) -> Result<bool, ()> {
+fn compile_and_run_interactively(exercise: &Exercise) -> Result<bool, ()> {
     let progress_bar = ProgressBar::new_spinner();
-    progress_bar.set_message(format!("Testing {}...", exercise).as_str());
+    progress_bar.set_message(format!("Compiling {}...", exercise).as_str());
     progress_bar.enable_steady_tick(100);
 
-    let compilation_result = exercise.compile();
+    let compilation = compile(&exercise, &progress_bar)?;
 
-    let compilation = match compilation_result {
-        Ok(compilation) => compilation,
+    progress_bar.set_message(format!("Running {}...", exercise).as_str());
+    let result = compilation.run();
+    progress_bar.finish_and_clear();
+
+    let output = match result {
+        Ok(output) => output,
         Err(output) => {
-            progress_bar.finish_and_clear();
-            warn!(
-                "Compiling of {} failed! Please try again. Here's the output:",
-                exercise
-            );
-            println!("{}", output.stderr);
+            warn!("Ran {} with errors", exercise);
+            println!("{}", output.stdout);
             return Err(());
         }
     };
 
+    success!("Successfully ran {}!", exercise);
+
+    Ok(prompt_for_completion(&exercise, Some(output.stdout)))
+}
+
+fn compile_and_test(exercise: &Exercise, run_mode: RunMode) -> Result<bool, ()> {
+    let progress_bar = ProgressBar::new_spinner();
+    progress_bar.set_message(format!("Testing {}...", exercise).as_str());
+    progress_bar.enable_steady_tick(100);
+
+    let compilation = compile(exercise, &progress_bar)?;
     let result = compilation.run();
     progress_bar.finish_and_clear();
 
     match result {
         Ok(_) => {
+            success!("Successfully tested {}", &exercise);
             if let RunMode::Interactive = run_mode {
-                Ok(prompt_for_completion(&exercise))
+                Ok(prompt_for_completion(&exercise, None))
             } else {
                 Ok(true)
             }
@@ -91,7 +92,27 @@ fn compile_and_test(exercise: &Exercise, run_mode: RunMode) -> Result<bool, ()>
     }
 }
 
-fn prompt_for_completion(exercise: &Exercise) -> bool {
+fn compile<'a, 'b>(
+    exercise: &'a Exercise,
+    progress_bar: &'b ProgressBar,
+) -> Result<CompiledExercise<'a>, ()> {
+    let compilation_result = exercise.compile();
+
+    match compilation_result {
+        Ok(compilation) => Ok(compilation),
+        Err(output) => {
+            progress_bar.finish_and_clear();
+            warn!(
+                "Compiling of {} failed! Please try again. Here's the output:",
+                exercise
+            );
+            println!("{}", output.stderr);
+            Err(())
+        }
+    }
+}
+
+fn prompt_for_completion(exercise: &Exercise, prompt_output: Option<String>) -> bool {
     let context = match exercise.state() {
         State::Done => return true,
         State::Pending(context) => context,
@@ -106,6 +127,15 @@ fn prompt_for_completion(exercise: &Exercise) -> bool {
     println!("");
     println!("🎉 🎉  {} 🎉 🎉", success_msg);
     println!("");
+
+    if let Some(output) = prompt_output {
+        println!("Output:");
+        println!("{}", separator());
+        println!("{}", output);
+        println!("{}", separator());
+        println!("");
+    }
+
     println!("You can keep working on this exercise,");
     println!(
         "or jump into the next one by removing the {} comment:",
@@ -129,3 +159,7 @@ fn prompt_for_completion(exercise: &Exercise) -> bool {
 
     false
 }
+
+fn separator() -> console::StyledObject<&'static str> {
+    style("====================").bold()
+}

tests/integration_tests.rs

@@ -31,7 +31,7 @@ fn verify_all_success() {
 }
 
 #[test]
-fn verify_all_failure() {
+fn verify_fails_if_some_fails() {
     Command::cargo_bin("rustlings")
         .unwrap()
         .arg("v")