1.3.0

Remove highlighting and syntect

Closes #166 and #122

.gitignore

@@ -1,5 +1,4 @@
 *.swp
 target/
 **/*.rs.bk
-Cargo.lock
 .DS_Store

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustlings"
-version = "1.2.0"
+version = "1.3.0"
 authors = ["Olivia <819880950@qq.com>", "Carol (Nichols || Goulding) <carol.nichols@gmail.com"]
 edition = "2018"
 
@@ -8,7 +8,6 @@ edition = "2018"
 clap = "2.32.0"
 indicatif = "0.9.0"
 console = "0.6.2"
-syntect = "3.0.2"
 notify = "4.0.0"
 toml = "0.4.10"
 serde = {version = "1.0.10", features = ["derive"]}

default_out.txt

@@ -1,6 +1,6 @@
-Thanks for installing `rustlings`!
+Thanks for installing Rustlings!
 
-## Is this your first time?
+Is this your first time?
 
 Let's make sure you're up to speed:
 - You have Rust installed, preferably via `rustup`
@@ -9,9 +9,7 @@ Let's make sure you're up to speed:
 - You have installed Rust language support for your editor
 - You have locally installed the `rustlings` command by running:
 
-```sh
 cargo install --path .
-```
 
 If you've done all of this (or even most of it), congrats! You're ready
 to start working with Rust.

exercises/error_handling/errors1.rs

@@ -63,7 +63,7 @@ mod tests {
 // `Option`.
 
 // To make this change, you'll need to:
-// - update the return type in the function signature to be a Result that
+// - update the return type in the function signature to be a Result<String, String> that
 //   could be the variants `Ok(String)` and `Err(String)`
 // - change the body of the function to return `Ok(stuff)` where it currently
 //   returns `Some(stuff)`

exercises/error_handling/errors2.rs

@@ -32,10 +32,7 @@ mod tests {
 
     #[test]
     fn item_quantity_is_a_valid_number() {
-        assert_eq!(
-            total_cost("34"),
-            Ok(171)
-        );
+        assert_eq!(total_cost("34"), Ok(171));
     }
 
     #[test]

exercises/error_handling/errorsn.rs

@@ -65,7 +65,7 @@ fn test_ioerror() {
     assert_eq!("uh-oh!", read_and_validate(&mut b).unwrap_err().to_string());
 }
 
-#[derive(PartialEq,Debug)]
+#[derive(PartialEq, Debug)]
 struct PositiveNonzeroInteger(u64);
 
 impl PositiveNonzeroInteger {
@@ -83,11 +83,14 @@ impl PositiveNonzeroInteger {
 #[test]
 fn test_positive_nonzero_integer_creation() {
     assert!(PositiveNonzeroInteger::new(10).is_ok());
-    assert_eq!(Err(CreationError::Negative), PositiveNonzeroInteger::new(-10));
+    assert_eq!(
+        Err(CreationError::Negative),
+        PositiveNonzeroInteger::new(-10)
+    );
     assert_eq!(Err(CreationError::Zero), PositiveNonzeroInteger::new(0));
 }
 
-#[derive(PartialEq,Debug)]
+#[derive(PartialEq, Debug)]
 enum CreationError {
     Negative,
     Zero,
@@ -108,16 +111,84 @@ impl error::Error for CreationError {
     }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // First hint: To figure out what type should go where the ??? is, take a look
 // at the test helper function `test_with_str`, since it returns whatever
 // `read_and_validate` returns and`test_with_str` has its signature fully
 // specified.
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // Next hint: There are three places in `read_and_validate` that we call a
 // function that returns a `Result` (that is, the functions might fail).
 // Apply the `?` operator on those calls so that we return immediately from
 // `read_and_validate` if those function calls fail.
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // Another hint: under the hood, the `?` operator calls `From::from`
 // on the error value to convert it to a boxed trait object, a Box<error::Error>,
 // which is polymorphic-- that means that lots of different kinds of errors
@@ -126,12 +197,50 @@ impl error::Error for CreationError {
 // Check out this section of the book:
 // https://doc.rust-lang.org/stable/book/second-edition/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // Another another hint: Note that because the `?` operator returns
 // the *unwrapped* value in the `Ok` case, if we want to return a `Result` from
 // `read_and_validate` for *its* success case, we'll have to rewrap a value
 // that we got from the return value of a `?`ed call in an `Ok`-- this will
 // look like `Ok(something)`.
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // Another another another hint: `Result`s must be "used", that is, you'll
 // get a warning if you don't handle a `Result` that you get in your
 // function. Read more about that in the `std::result` module docs:

exercises/error_handling/option1.rs

@@ -11,7 +11,10 @@ fn main() {
     println!("The last item in the list is {:?}", last);
 
     let second_to_last = list.pop().unwrap();
-    println!("The second-to-last item in the list is {:?}", second_to_last);
+    println!(
+        "The second-to-last item in the list is {:?}",
+        second_to_last
+    );
 }
 
 

exercises/error_handling/result1.rs

@@ -1,10 +1,10 @@
 // result1.rs
 // Make this test pass! Scroll down for hints :)
 
-#[derive(PartialEq,Debug)]
+#[derive(PartialEq, Debug)]
 struct PositiveNonzeroInteger(u64);
 
-#[derive(PartialEq,Debug)]
+#[derive(PartialEq, Debug)]
 enum CreationError {
     Negative,
     Zero,
@@ -19,7 +19,10 @@ impl PositiveNonzeroInteger {
 #[test]
 fn test_creation() {
     assert!(PositiveNonzeroInteger::new(10).is_ok());
-    assert_eq!(Err(CreationError::Negative), PositiveNonzeroInteger::new(-10));
+    assert_eq!(
+        Err(CreationError::Negative),
+        PositiveNonzeroInteger::new(-10)
+    );
     assert_eq!(Err(CreationError::Zero), PositiveNonzeroInteger::new(0));
 }
 

exercises/modules/README.md

@@ -4,4 +4,4 @@ In this section we'll give you an introduction to Rust's module system.
 
 #### Book Sections
 
-- [The Module System](https://doc.rust-lang.org/stable/book/ch07-02-modules-and-use-to-control-scope-and-privacy.html)
+- [The Module System](https://doc.rust-lang.org/stable/book/ch07-02-defining-modules-to-control-scope-and-privacy.html)

exercises/standard_library_types/README.md

@@ -1,5 +1,5 @@
-For the Arc exercise check out the chapter [Shared-State Concurrency](https://doc.rust-lang.org/book/2018-edition/ch16-03-shared-state.html) of the Rust Book.
+For the Arc exercise check out the chapter [Shared-State Concurrency](https://doc.rust-lang.org/book/ch16-03-shared-state.html) of the Rust Book.
 
-For the Iterator exercise check out the chapters [Iterator](https://doc.rust-lang.org/book/2018-edition/ch13-02-iterators.html) of the Rust Book and the [Iterator documentation](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.htmlj).
+For the Iterator exercise check out the chapters [Iterator](https://doc.rust-lang.org/book/ch13-02-iterators.html) of the Rust Book and the [Iterator documentation](https://doc.rust-lang.org/stable/std/iter/).
 Do not adjust your monitors-- iterators 1 and 2 are indeed missing. Iterator 3 is a bit challenging so we're leaving space for some exercises to lead up to it!
 

exercises/standard_library_types/iterator3.rs

@@ -114,7 +114,7 @@ mod tests {
 
 
 
-// Minor hint: In each of the two cases in the match in main, you can create x with either 
+// Minor hint: In each of the two cases in the match in main, you can create x with either
 // a 'turbofish' or by hinting the type of x to the compiler. You may try both.
 
 
@@ -143,5 +143,5 @@ mod tests {
 
 
 
-// Major hint: Have a look at the Iter trait and at the explanation of its collect function. 
+// Major hint: Have a look at the Iter trait and at the explanation of its collect function.
 // Especially the part about Result is interesting.

exercises/structs/README.md

@@ -0,0 +1,7 @@
+### Strings
+
+Rust has three struct types: a classic c struct, a tuple struct, and a unit struct.
+
+#### Book Sections
+
+- [Structures](https://doc.rust-lang.org/rust-by-example/custom_types/structs.html)

exercises/structs/structs1.rs

@@ -0,0 +1,46 @@
+// structs1.rs
+// Address all the TODOs to make the tests pass!
+
+struct ColorClassicStruct {
+    // TODO: Something goes here
+}
+
+struct ColorTupleStruct(/* TODO: Something goes here */);
+
+struct ColorUnitStruct;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn classic_c_structs() {
+        // TODO: Instantiate a classic c struct!
+        // let green =
+
+        assert_eq!(green.name, "green");
+        assert_eq!(green.hex, "#00FF00");
+    }
+
+    #[test]
+    fn tuple_structs() {
+        // TODO: Instantiate a tuple struct!
+        // For more fun, use the field initialization shorthand.
+        // let green =
+
+        assert_eq!(green.0, "green");
+        assert_eq!(green.1, "#00FF00");
+    }
+
+    #[test]
+    fn unit_structs() {
+        // TODO: Instantiate a unit struct!
+        // let green =
+
+        if let ColorUnitStruct = green {
+            assert!(true);
+        } else {
+            assert!(false);
+        }
+    }
+}

exercises/threads/README.md

@@ -1 +1 @@
-For this exercise check out the [Dining Philosophers example](https://doc.rust-lang.org/1.4.0/book/dining-philosophers.html) and the chapter [Concurrency](https://doc.rust-lang.org/book/2018-edition/ch16-01-threads.html) of the Rust Book.
+For this exercise check out the [Dining Philosophers example](https://doc.rust-lang.org/1.4.0/book/dining-philosophers.html) and the chapter [Concurrency](https://doc.rust-lang.org/book/ch16-01-threads.html) of the Rust Book.

info.toml

@@ -76,6 +76,12 @@ mode = "compile"
 path = "exercises/primitive_types/primitive_types6.rs"
 mode = "compile"
 
+# STRUCTS
+
+[[exercises]]
+path = "exercises/structs/structs1.rs"
+mode = "test"
+
 # TESTS
 
 [[exercises]]

src/exercise.rs

@@ -1,7 +1,7 @@
 use serde::Deserialize;
 use std::fmt::{self, Display, Formatter};
-use std::fs::{remove_file};
-use std::path::{PathBuf};
+use std::fs::remove_file;
+use std::path::PathBuf;
 use std::process::{self, Command, Output};
 
 const RUSTC_COLOR_ARGS: &[&str] = &["--color", "always"];
@@ -38,7 +38,6 @@ impl Exercise {
             Mode::Test => Command::new("rustc")
                 .args(&["--test", self.path.to_str().unwrap(), "-o", &temp_file()])
                 .args(RUSTC_COLOR_ARGS)
-                .args(&["--", "--nocapture"])
                 .output(),
         }
         .expect("Failed to run 'compile' command.")
@@ -64,8 +63,8 @@ impl Display for Exercise {
 #[cfg(test)]
 mod test {
     use super::*;
-    use std::path::Path;
     use std::fs::File;
+    use std::path::Path;
 
     #[test]
     fn test_clean() {

src/main.rs

@@ -6,14 +6,9 @@ use notify::DebouncedEvent;
 use notify::{RecommendedWatcher, RecursiveMode, Watcher};
 use std::ffi::OsStr;
 use std::fs;
-use std::io::BufRead;
 use std::path::Path;
 use std::sync::mpsc::channel;
 use std::time::Duration;
-use syntect::easy::HighlightFile;
-use syntect::highlighting::{Style, ThemeSet};
-use syntect::parsing::SyntaxSet;
-use syntect::util::as_24_bit_terminal_escaped;
 
 mod exercise;
 mod run;
@@ -35,9 +30,6 @@ fn main() {
         )
         .get_matches();
 
-    let ss = SyntaxSet::load_defaults_newlines();
-    let ts = ThemeSet::load_defaults();
-
     if None == matches.subcommand_name() {
         println!();
         println!(r#"       welcome to...                      "#);
@@ -55,6 +47,7 @@ fn main() {
             "{} must be run from the rustlings directory",
             std::env::current_exe().unwrap().to_str().unwrap()
         );
+        println!("Try `cd rustlings/`!");
         std::process::exit(1);
     }
 
@@ -91,13 +84,8 @@ fn main() {
     }
 
     if matches.subcommand_name().is_none() {
-        let mut highlighter =
-            HighlightFile::new("default_out.md", &ss, &ts.themes["base16-eighties.dark"]).unwrap();
-        for maybe_line in highlighter.reader.lines() {
-            let line = maybe_line.unwrap();
-            let regions: Vec<(Style, &str)> = highlighter.highlight_lines.highlight(&line, &ss);
-            println!("{}", as_24_bit_terminal_escaped(&regions[..], true));
-        }
+        let text = fs::read_to_string("default_out.txt").unwrap();
+        println!("{}", text);
     }
 
     println!("\x1b[0m");

src/run.rs

@@ -1,4 +1,4 @@
-use crate::exercise::{Mode, Exercise};
+use crate::exercise::{Exercise, Mode};
 use crate::verify::test;
 use console::{style, Emoji};
 use indicatif::ProgressBar;

src/verify.rs

@@ -2,7 +2,7 @@ use crate::exercise::{Exercise, Mode};
 use console::{style, Emoji};
 use indicatif::ProgressBar;
 
-pub fn verify<'a>(start_at: impl IntoIterator<Item=&'a Exercise>) -> Result<(), ()> {
+pub fn verify<'a>(start_at: impl IntoIterator<Item = &'a Exercise>) -> Result<(), ()> {
     for exercise in start_at {
         match exercise.mode {
             Mode::Test => test(&exercise)?,

tests/fixture/failure/testNotPassed.rs

@@ -0,0 +1,4 @@
+#[test]
+fn not_passing() {
+    assert!(false);
+}

tests/integration_tests.rs

@@ -76,6 +76,16 @@ fn run_single_test_failure() {
         .code(1);
 }
 
+#[test]
+fn run_single_test_not_passed() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(&["r", "testNotPassed.rs"])
+        .current_dir("tests/fixture/failure/")
+        .assert()
+        .code(1);
+}
+
 #[test]
 fn run_single_test_no_filename() {
     Command::cargo_bin("rustlings")