fixes

Author: celaus

Chapter01/testing/src/lib.rs

@@ -139,52 +139,6 @@ impl<T> List<T> where T: Sized + Clone  {
                 .value
         })
     }
-
-
-    ///
-    /// Splits off and returns `n` nodes as a `List<T>`.  
-    /// 
-    /// # Arguments
-    /// 
-    /// `n: usize` - The number of elements after which to split the list. 
-    /// 
-    /// # Panics
-    /// 
-    /// Panics when: 
-    ///  - The list is empty
-    ///  - `n` is larger than the length
-    /// 
-    /// # Example
-    /// 
-    /// ```
-    /// # use testing::List;
-    /// 
-    /// let mut list = List::new_empty(); 
-    /// list.append(12);
-    /// list.append(11);
-    /// list.append(10);
-    /// let mut list2 = list.split(1);
-    /// assert_eq!(list2.pop(), Some(12));
-    /// assert_eq!(list.pop(), Some(11));
-    /// assert_eq!(list.pop(), Some(10));
-    /// ```
-    /// 
-    pub fn split(&mut self, n: usize) -> List<T> {
-
-        // Don't do this in real life. Use Results, Options, or anything that 
-        // doesn't just kill the program
-        if self.length == 0 || n >=  self.length - 1 {
-            panic!("That's not working");
-        }
-
-        let mut n = n;
-        let mut new_list = List::new_empty();
-        while n > 0 {
-            new_list.append(self.pop().unwrap());
-            n -= 1;
-        }
-        new_list
-    }
 }
 
 impl <T>Drop for List<T> where T: Clone + Sized {
@@ -225,7 +179,7 @@ mod tests {
         list.append(1);
         list.append(1);
         list.append(1);
-        list.append(1);
+        list.append(1);     
         list.append(1);
         assert_eq!(list.length, 5);
     }
@@ -248,25 +202,4 @@ mod tests {
         assert_eq!(list.length, 0);
         assert_eq!(list.pop(), None);
     }
-
-    #[test]
-    fn test_list_split() {
-        let mut list = List::new_empty();
-        list.append(1);
-        list.append(1);
-        list.append(1);
-        list.append(1);
-        list.append(1);
-        assert_eq!(list.length, 5);
-        let list2 = list.split(3);
-        assert_eq!(list.length, 2);
-        assert_eq!(list2.length, 3);
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_list_split_panics() {
-        let mut list: List<i32> = List::new_empty();
-        let _ = list.split(3);
-    }
 }

Chapter01/traits/src/lib.rs

@@ -1,40 +1,38 @@
-use std::io::{Write, Read};
+use std::io::{Read, Write};
 // Structs
 
 ///
 /// Configuration for our application
-/// 
+///
 pub struct Config {
-    values: Vec<(String, String)>
+    values: Vec<(String, String)>,
 }
 
 ///
 /// A service for managing a configuration
-/// 
-pub struct KeyValueConfigService {
-
-}
+///
+pub struct KeyValueConfigService {}
 
 // Traits
 
 ///
-/// Provides a get() function to return valuse associated with
+/// Provides a get() function to return values associated with
 /// the specified key.
-/// 
+///
 pub trait ValueGetter {
     fn get(&self, s: &str) -> Option<String>;
 }
 
 ///
 /// Write a config
-/// 
+///
 pub trait ConfigWriter {
     fn write(&self, config: Config, to: &mut impl Write) -> std::io::Result<()>;
 }
 
 ///
 /// Read a config
-/// 
+///
 pub trait ConfigReader {
     fn read(&self, from: &mut impl Read) -> std::io::Result<Config>;
 }
@@ -43,16 +41,13 @@ pub trait ConfigReader {
 
 impl Config {
     pub fn new(values: Vec<(String, String)>) -> Config {
-        Config {
-            values: values
-        }
+        Config { values: values }
     }
 }
 
 impl KeyValueConfigService {
     pub fn new() -> KeyValueConfigService {
-        KeyValueConfigService {
-        }
+        KeyValueConfigService {}
     }
 }
 
@@ -72,34 +67,35 @@ impl ConfigReader for KeyValueConfigService {
 
         // chain iterators together and collect the results
         let values: Vec<(String, String)> = buffer
-            .split_terminator("\n")  // split
+            .split_terminator("\n") // split
             .map(|line| line.trim()) // remove whitespace
-            .filter(|line| {         // filter invalid lines
-                let pos = line.find("=")
-                    .unwrap_or(0);
+            .filter(|line| {
+                // filter invalid lines
+                let pos = line.find("=").unwrap_or(0);
                 pos > 0 && pos < line.len() - 1
             })
-            .map(|line| {            // create a tuple from a line 
+            .map(|line| {
+                // create a tuple from a line
                 let parts = line.split("=").collect::<Vec<&str>>();
                 (parts[0].to_string(), parts[1].to_string())
             })
-            .collect();              // transform it into a vector
+            .collect(); // transform it into a vector
         Ok(Config::new(values))
     }
 }
 
 impl ValueGetter for Config {
     fn get(&self, s: &str) -> Option<String> {
-        self.values.iter()
-            .find_map(|tuple| if &tuple.0 == s {
-                    Some(tuple.1.clone())
-                } else {
-                    None
-            })
+        self.values.iter().find_map(|tuple| {
+            if &tuple.0 == s {
+                Some(tuple.1.clone())
+            } else {
+                None
+            }
+        })
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -112,7 +108,6 @@ mod tests {
         assert_eq!(config.get("HELLO"), None);
     }
 
-
     #[test]
     fn keyvalueconfigservice_write_config() {
         let config = Config::new(vec![("hello".to_string(), "world".to_string())]);
@@ -121,20 +116,27 @@ mod tests {
         let mut target = vec![];
         assert!(service.write(config, &mut target).is_ok());
 
-        assert_eq!(String::from_utf8(target).unwrap(), "hello=world\n".to_string());
+        assert_eq!(
+            String::from_utf8(target).unwrap(),
+            "hello=world\n".to_string()
+        );
     }
 
-     #[test]
+    #[test]
     fn keyvalueconfigservice_read_config() {
-
         let service = KeyValueConfigService::new();
         let readable = &format!("{}\n{}", "hello=world", "a=b").into_bytes();
-        
-        let config = service.read(&mut Cursor::new(readable))
+
+        let config = service
+            .read(&mut Cursor::new(readable))
             .expect("Couldn't read from the vector");
 
-        assert_eq!(config.values, vec![
+        assert_eq!(
+            config.values,
+            vec![
                 ("hello".to_string(), "world".to_string()),
-                ("a".to_string(), "b".to_string())]);
+                ("a".to_string(), "b".to_string())
+            ]
+        );
     }
-}
+}

Chapter02/mut-sharing-ownership/src/lib.rs

@@ -1,7 +1,5 @@
 #![feature(test)]
 
-//pub mod list;
-
 #[cfg(test)]
 mod tests {
     extern crate test;