trackler 2.2.1.129 → 2.2.1.130

data/tracks/rust/_test/check-stubs.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# This checks every stub which exists, and emits all of their warnings.
+# To get a list of exercises for which there are warnings on compilation,
+# run it like this:
+#
+# $ _test/check-stubs.sh 2>/dev/null | rev | cut -d/ -f1 | rev
+
+# run 'cargo check' on every exercise which possesses a stub
+repo=$(cd "$(dirname "$0")/.." && pwd)
+
+for stub in $repo/exercises/*/src/lib.rs; do
+    exercise=$(dirname $(dirname $stub))
+    (
+        cd "$exercise"
+        # copy the original stub to a backup
+        backup=$(dirname $stub)/lib.rs.bak
+        cp $stub $backup
+        # deny warnings in the stub
+        sed -i -e '1i #![deny(warnings)]' $stub
+        # quiet so that we only get output when there's an error
+        cargo check --quiet
+        if [ $? != 0 ]; then
+            echo "^- $exercise"
+        fi
+        # reset
+        mv -f $backup $stub
+    )
+done

data/tracks/rust/_test/ensure-stubs-compile.sh

@@ -12,16 +12,35 @@ for dir in $repo/exercises/*/; do
   if grep -v '^//' $dir/src/lib.rs | grep '\S' > /dev/null; then
     allowed_file=$dir/.meta/ALLOWED_TO_NOT_COMPILE
 
-    # In Travis CI, we may have already compiled using the example solution.
-    # Touch the src/lib.rs file so that we surely recompile using the stub.
-    touch $dir/src/lib.rs
-
     if [ -f $allowed_file ]; then
       echo "$exercise's stub is allowed to not compile"
-    elif ! (cd $dir && cargo test --quiet --no-run); then
+      continue
+    fi
+
+    # Backup tests and stub; this script will modify them.
+    cp -r $dir/tests $dir/tests.orig
+    cp $dir/src/lib.rs $dir/lib.rs.orig
+
+    # This sed serves two purposes:
+    # First, in Travis CI, we may have already compiled using the example solution.
+    # Edit the src/lib.rs file so that we surely recompile using the stub.
+    # Second, ensures that the stub compiles without warnings.
+    sed -i -e '1i #![deny(warnings)]' "$dir/src/lib.rs"
+
+    # Deny warnings in the tests that may result from compiling the stubs.
+    # This helps avoid, for example, an overflowing literal warning
+    # that could be caused by a stub with a type that is too small.
+    sed -i -e '1i #![deny(warnings)]' $dir/tests/*.rs
+
+    if ! (cd $dir && cargo test --quiet --no-run); then
       echo "$exercise's stub does not compile; please make it compile or remove all non-commented lines"
       broken="$broken\n$exercise"
     fi
+
+    # Restore tests and stub.
+    mv $dir/lib.rs.orig $dir/src/lib.rs
+    rm -r $dir/tests
+    mv $dir/tests.orig $dir/tests
   fi
 done
 

data/tracks/rust/exercises/all-your-base/src/lib.rs

@@ -36,7 +36,6 @@ pub enum Error {
 ///  * Never output leading 0 digits. However, your function must be able to
 ///     process input with leading 0 digits.
 ///
-#[allow(unused_variables)]
 pub fn convert(number: &[u32], from_base: u32, to_base: u32) -> Result<Vec<u32>, Error> {
-    unimplemented!()
+    unimplemented!("Convert {:?} from base {} to base {}", number, from_base, to_base)
 }

data/tracks/rust/exercises/armstrong-numbers/src/lib.rs

@@ -1,3 +1,3 @@
-pub fn is_armstrong_number(_num: u32) -> bool {
-    unimplemented!()
+pub fn is_armstrong_number(num: u32) -> bool {
+    unimplemented!("true if {} is an armstrong number", num)
 }

data/tracks/rust/exercises/beer-song/src/lib.rs

@@ -1,7 +1,7 @@
 pub fn verse(n: i32) -> String {
-    unimplemented!()
+    unimplemented!("emit verse {}", n)
 }
 
 pub fn sing(start: i32, end: i32) -> String {
-    unimplemented!()
+    unimplemented!("sing verses {} to {}, inclusive", start, end)
 }

data/tracks/rust/exercises/bob/src/lib.rs

@@ -1,3 +1,3 @@
 pub fn reply(message: &str) -> &str {
-    unimplemented!()
+    unimplemented!("have Bob reply to the incoming message: {}", message)
 }

data/tracks/rust/exercises/circular-buffer/tests/circular-buffer.rs

@@ -1,113 +1,108 @@
 extern crate circular_buffer;
+use circular_buffer::{CircularBuffer, Error};
 
-#[allow(unused_must_use)]
-mod tests {
-
-    use circular_buffer::{CircularBuffer, Error};
-
-    #[test]
-    fn error_on_read_empty_buffer() {
-        let mut buffer = CircularBuffer::<char>::new(1);
-        assert_eq!(Err(Error::EmptyBuffer), buffer.read());
-    }
+#[test]
+fn error_on_read_empty_buffer() {
+    let mut buffer = CircularBuffer::<char>::new(1);
+    assert_eq!(Err(Error::EmptyBuffer), buffer.read());
+}
 
-    #[test]
-    #[ignore]
-    fn write_and_read_back_item() {
-        let mut buffer = CircularBuffer::new(1);
-        buffer.write('1');
-        assert_eq!(Ok('1'), buffer.read());
-        assert_eq!(Err(Error::EmptyBuffer), buffer.read());
-    }
+#[test]
+#[ignore]
+fn write_and_read_back_item() {
+    let mut buffer = CircularBuffer::new(1);
+    assert!(buffer.write('1').is_ok());
+    assert_eq!(Ok('1'), buffer.read());
+    assert_eq!(Err(Error::EmptyBuffer), buffer.read());
+}
 
-    #[test]
-    #[ignore]
-    fn write_and_read_back_multiple_items() {
-        let mut buffer = CircularBuffer::new(2);
-        buffer.write('1');
-        buffer.write('2');
-        assert_eq!(Ok('1'), buffer.read());
-        assert_eq!(Ok('2'), buffer.read());
-        assert_eq!(Err(Error::EmptyBuffer), buffer.read());
-    }
+#[test]
+#[ignore]
+fn write_and_read_back_multiple_items() {
+    let mut buffer = CircularBuffer::new(2);
+    assert!(buffer.write('1').is_ok());
+    assert!(buffer.write('2').is_ok());
+    assert_eq!(Ok('1'), buffer.read());
+    assert_eq!(Ok('2'), buffer.read());
+    assert_eq!(Err(Error::EmptyBuffer), buffer.read());
+}
 
-    #[test]
-    #[ignore]
-    fn alternate_write_and_read() {
-        let mut buffer = CircularBuffer::new(2);
-        buffer.write('1');
-        assert_eq!(Ok('1'), buffer.read());
-        buffer.write('2');
-        assert_eq!(Ok('2'), buffer.read());
-    }
+#[test]
+#[ignore]
+fn alternate_write_and_read() {
+    let mut buffer = CircularBuffer::new(2);
+    assert!(buffer.write('1').is_ok());
+    assert_eq!(Ok('1'), buffer.read());
+    assert!(buffer.write('2').is_ok());
+    assert_eq!(Ok('2'), buffer.read());
+}
 
-    #[test]
-    #[ignore]
-    fn clear_buffer() {
-        let mut buffer = CircularBuffer::new(3);
-        buffer.write('1');
-        buffer.write('2');
-        buffer.write('3');
-        buffer.clear();
-        assert_eq!(Err(Error::EmptyBuffer), buffer.read());
-        buffer.write('1');
-        buffer.write('2');
-        assert_eq!(Ok('1'), buffer.read());
-        buffer.write('3');
-        assert_eq!(Ok('2'), buffer.read());
-    }
+#[test]
+#[ignore]
+fn clear_buffer() {
+    let mut buffer = CircularBuffer::new(3);
+    assert!(buffer.write('1').is_ok());
+    assert!(buffer.write('2').is_ok());
+    assert!(buffer.write('3').is_ok());
+    buffer.clear();
+    assert_eq!(Err(Error::EmptyBuffer), buffer.read());
+    assert!(buffer.write('1').is_ok());
+    assert!(buffer.write('2').is_ok());
+    assert_eq!(Ok('1'), buffer.read());
+    assert!(buffer.write('3').is_ok());
+    assert_eq!(Ok('2'), buffer.read());
+}
 
-    #[test]
-    #[ignore]
-    fn full_buffer_error() {
-        let mut buffer = CircularBuffer::new(2);
-        buffer.write('1');
-        buffer.write('2');
-        assert_eq!(Err(Error::FullBuffer), buffer.write('3'));
-    }
+#[test]
+#[ignore]
+fn full_buffer_error() {
+    let mut buffer = CircularBuffer::new(2);
+    assert!(buffer.write('1').is_ok());
+    assert!(buffer.write('2').is_ok());
+    assert_eq!(Err(Error::FullBuffer), buffer.write('3'));
+}
 
-    #[test]
-    #[ignore]
-    fn overwrite_item_in_non_full_buffer() {
-        let mut buffer = CircularBuffer::new(2);
-        buffer.write('1');
-        buffer.overwrite('2');
-        assert_eq!(Ok('1'), buffer.read());
-        assert_eq!(Ok('2'), buffer.read());
-        assert_eq!(Err(Error::EmptyBuffer), buffer.read());
-    }
+#[test]
+#[ignore]
+fn overwrite_item_in_non_full_buffer() {
+    let mut buffer = CircularBuffer::new(2);
+    assert!(buffer.write('1').is_ok());
+    buffer.overwrite('2');
+    assert_eq!(Ok('1'), buffer.read());
+    assert_eq!(Ok('2'), buffer.read());
+    assert_eq!(Err(Error::EmptyBuffer), buffer.read());
+}
 
-    #[test]
-    #[ignore]
-    fn overwrite_item_in_full_buffer() {
-        let mut buffer = CircularBuffer::new(2);
-        buffer.write('1');
-        buffer.write('2');
-        buffer.overwrite('A');
-        assert_eq!(Ok('2'), buffer.read());
-        assert_eq!(Ok('A'), buffer.read());
-    }
+#[test]
+#[ignore]
+fn overwrite_item_in_full_buffer() {
+    let mut buffer = CircularBuffer::new(2);
+    assert!(buffer.write('1').is_ok());
+    assert!(buffer.write('2').is_ok());
+    buffer.overwrite('A');
+    assert_eq!(Ok('2'), buffer.read());
+    assert_eq!(Ok('A'), buffer.read());
+}
 
-    #[test]
-    #[ignore]
-    fn integer_buffer() {
-        let mut buffer = CircularBuffer::new(2);
-        buffer.write(1);
-        buffer.write(2);
-        assert_eq!(Ok(1), buffer.read());
-        buffer.write(-1);
-        assert_eq!(Ok(2), buffer.read());
-        assert_eq!(Ok(-1), buffer.read());
-        assert_eq!(Err(Error::EmptyBuffer), buffer.read());
-    }
+#[test]
+#[ignore]
+fn integer_buffer() {
+    let mut buffer = CircularBuffer::new(2);
+    assert!(buffer.write(1).is_ok());
+    assert!(buffer.write(2).is_ok());
+    assert_eq!(Ok(1), buffer.read());
+    assert!(buffer.write(-1).is_ok());
+    assert_eq!(Ok(2), buffer.read());
+    assert_eq!(Ok(-1), buffer.read());
+    assert_eq!(Err(Error::EmptyBuffer), buffer.read());
+}
 
-    #[test]
-    #[ignore]
-    fn string_buffer() {
-        let mut buffer = CircularBuffer::new(2);
-        buffer.write("".to_string());
-        buffer.write("Testing".to_string());
-        assert_eq!(0, buffer.read().unwrap().len());
-        assert_eq!(Ok("Testing".to_string()), buffer.read());
-    }
+#[test]
+#[ignore]
+fn string_buffer() {
+    let mut buffer = CircularBuffer::new(2);
+    buffer.write("".to_string()).unwrap();
+    buffer.write("Testing".to_string()).unwrap();
+    assert_eq!(0, buffer.read().unwrap().len());
+    assert_eq!(Ok("Testing".to_string()), buffer.read());
 }

data/tracks/rust/exercises/collatz-conjecture/src/lib.rs

@@ -1,4 +1,6 @@
-// return Some(x) where x is the number of steps required to reach 1
 pub fn collatz(n: u64) -> Option<u64> {
-    unimplemented!()
+    unimplemented!(
+        "return Some(x) where x is the number of steps required to reach 1 starting with {}",
+        n,
+    )
 }

data/tracks/rust/exercises/decimal/.meta/description.md

@@ -15,5 +15,5 @@ It would be very easy to implement this exercise by using the [bigdecimal](https
 # Hints
 
 - Instead of implementing arbitrary-precision arithmetic from scratch, consider building your type on top of the [num_bigint](https://crates.io/crates/num-bigint) crate.
-- You might be able to [derive](https://doc.rust-lang.org/book/first-edition/traits.html#deriving) some of the required traits.
+- You might be able to [derive](https://doc.rust-lang.org/book/second-edition/appendix-03-derivable-traits.html) some of the required traits.
 - `Decimal` is assumed to be a signed type. You do not have to create a separate unsigned type, though you may do so as an implementation detail if you so choose.

data/tracks/rust/exercises/decimal/README.md

@@ -17,7 +17,7 @@ It would be very easy to implement this exercise by using the [bigdecimal](https
 # Hints
 
 - Instead of implementing arbitrary-precision arithmetic from scratch, consider building your type on top of the [num_bigint](https://crates.io/crates/num-bigint) crate.
-- You might be able to [derive](https://doc.rust-lang.org/book/first-edition/traits.html#deriving) some of the required traits.
+- You might be able to [derive](https://doc.rust-lang.org/book/second-edition/appendix-03-derivable-traits.html) some of the required traits.
 - `Decimal` is assumed to be a signed type. You do not have to create a separate unsigned type, though you may do so as an implementation detail if you so choose.
 
 ## Rust Installation

data/tracks/rust/exercises/difference-of-squares/src/lib.rs

@@ -1,11 +1,14 @@
 pub fn square_of_sum(n: usize) -> usize {
-    unimplemented!()
+    unimplemented!("square of sum of 1...{}", n)
 }
 
 pub fn sum_of_squares(n: usize) -> usize {
-    unimplemented!()
+    unimplemented!("sum of squares of 1...{}", n)
 }
 
 pub fn difference(n: usize) -> usize {
-    unimplemented!()
+    unimplemented!(
+        "difference between square of sum of 1...{n} and sum of squares of 1...{n}",
+        n=n,
+    )
 }

data/tracks/rust/exercises/forth/src/lib.rs

@@ -21,6 +21,6 @@ impl Forth {
     }
 
     pub fn eval(&mut self, input: &str) -> ForthResult {
-        unimplemented!()
+        unimplemented!("result of evaluating '{}'", input)
     }
 }

data/tracks/rust/exercises/grade-school/src/lib.rs

@@ -1,5 +1,3 @@
-#[allow(unused_variables)]
-
 pub struct School {
 }
 
@@ -9,7 +7,7 @@ impl School {
     }
 
     pub fn add(&mut self, grade: u32, student: &str) {
-        unimplemented!()
+        unimplemented!("Add {} to the roster for {}", student, grade)
     }
 
     pub fn grades(&self) -> Vec<u32> {
@@ -21,6 +19,6 @@ impl School {
     // By returning an owned vector instead,
     // the internal implementation is free to use whatever it chooses.
     pub fn grade(&self, grade: u32) -> Option<Vec<String>> {
-        unimplemented!()
+        unimplemented!("Return the list of students in {}", grade)
     }
 }

data/tracks/rust/exercises/grains/src/lib.rs

@@ -1,5 +1,5 @@
 pub fn square(s: u32) -> u64 {
-    unimplemented!();
+    unimplemented!("grains of rice on square {}", s);
 }
 
 pub fn total() -> u64 {

data/tracks/rust/exercises/leap/src/lib.rs

@@ -1,3 +1,3 @@
 pub fn is_leap_year(year: i32) -> bool {
-    unimplemented!()
+    unimplemented!("true if {} is a leap year", year)
 }

data/tracks/rust/exercises/macros/.meta/description.md

@@ -8,7 +8,7 @@ What is a macro? [Wikipedia](https://en.wikipedia.org/wiki/Macro_(computer_scien
 
 Illuminating! But to be more concrete, macros are a special syntax which allows you to generate code at compile time. Macros can be used compile-time calculation, but more often they're just another way to abstract your code. For example, you've probably already used `println!()` and `vec![]`. These each take an arbitrary number of arguments, so you can't express them as simple functions. On the other hand, they always expand to some amount of absolutely standard Rust code. If you're interested, you can use the [cargo expand](https://github.com/dtolnay/cargo-expand) subcommand to view the results of macro expansion in your code.
 
-For further information about macros in Rust, The Rust Book has a [good chapter](https://doc.rust-lang.org/book/first-edition/macros.html) on them.
+For further information about macros in Rust, The Rust Book has a [good chapter](https://doc.rust-lang.org/book/second-edition/appendix-04-macros.html) on them.
 
 ## Problem Statement
 

data/tracks/rust/exercises/macros/README.md

@@ -10,7 +10,7 @@ What is a macro? [Wikipedia](https://en.wikipedia.org/wiki/Macro_(computer_scien
 
 Illuminating! But to be more concrete, macros are a special syntax which allows you to generate code at compile time. Macros can be used compile-time calculation, but more often they're just another way to abstract your code. For example, you've probably already used `println!()` and `vec![]`. These each take an arbitrary number of arguments, so you can't express them as simple functions. On the other hand, they always expand to some amount of absolutely standard Rust code. If you're interested, you can use the [cargo expand](https://github.com/dtolnay/cargo-expand) subcommand to view the results of macro expansion in your code.
 
-For further information about macros in Rust, The Rust Book has a [good chapter](https://doc.rust-lang.org/book/first-edition/macros.html) on them.
+For further information about macros in Rust, The Rust Book has a [good chapter](https://doc.rust-lang.org/book/second-edition/appendix-04-macros.html) on them.
 
 ## Problem Statement
 

data/tracks/rust/exercises/ocr-numbers/src/lib.rs

@@ -7,7 +7,6 @@ pub enum Error {
     InvalidColumnCount(usize),
 }
 
-#[allow(unused_variables)]
 pub fn convert(input: &str) -> Result<String, Error> {
-    unimplemented!();
+    unimplemented!("Convert the input '{}' to a string", input);
 }

data/tracks/rust/exercises/parallel-letter-frequency/.meta/hints.md

@@ -28,5 +28,5 @@ rustup run nightly cargo bench
 
 Learn more about nightly Rust:
 
-- [Nightly Rust](https://doc.rust-lang.org/book/first-edition/release-channels.html)
+- [Nightly Rust](https://doc.rust-lang.org/book/second-edition/ch01-03-how-rust-is-made-and-nightly-rust.html)
 - [Rustup: Working with nightly](https://github.com/rust-lang-nursery/rustup.rs#working-with-nightly-rust)