Fix cargo clippy warnings

Author: ritiek

.gitignore

@@ -1,2 +1,2 @@
 target/
-notes.yml
+*.yml

src/arguments.rs

@@ -19,12 +19,11 @@ impl Options {
     pub fn read() -> Options {
         let arguments = Self::get_arguments();
         let receiver_address = value_t!(arguments.value_of("receiver_address"), SocketAddr)
-            .unwrap_or("0.0.0.0:9999".parse().unwrap());
-        let default_host_address = receiver_address.clone();
+            .unwrap_or_else(|_| "0.0.0.0:9999".parse().unwrap());
 
         let parsed_arguments = Options {
             host_address     : value_t!(arguments.value_of("host_address"), SocketAddr)
-                                .unwrap_or(default_host_address),
+                                .unwrap_or(receiver_address),
             volume           : value_t!(arguments.value_of("volume"), f32)
                                 .unwrap_or(1.0),
             record_file      : value_t!(arguments.value_of("record_file"), String)
@@ -39,9 +38,9 @@ impl Options {
                                 .unwrap_or(0),
             mark_duration    : value_t!(arguments.value_of("mark_duration"), u64)
                                 .unwrap_or(500),
-            receiver_address : receiver_address,
+            receiver_address,
             sender_address   : value_t!(arguments.value_of("sender_address"), SocketAddr)
-                                .unwrap_or("0.0.0.0:0".parse().unwrap()),
+                                .unwrap_or_else(|_| "0.0.0.0:0".parse().unwrap()),
         };
 
         parsed_arguments

src/game.rs

@@ -33,12 +33,12 @@ impl PianoKeyboard {
         let player = Player::new();
 
         PianoKeyboard {
-            sequence: sequence,
-            volume: volume,
-            sound_duration: sound_duration,
-            mark_duration: mark_duration,
-            color: color,
-            player: player,
+            sequence,
+            volume,
+            sound_duration,
+            mark_duration,
+            color,
+            player,
             recorder: NoteRecorder::new(),
         }
     }
@@ -62,7 +62,7 @@ impl PianoKeyboard {
             self.mark_duration,
         );
 
-        if let Some(_) = &self.recorder.record_file {
+        if self.recorder.record_file.is_some(){
             self.recorder.write_note(note);
         }
     }
@@ -72,7 +72,7 @@ impl PianoKeyboard {
     }
 
     pub fn process_key(&mut self, key: KeyEvent) -> Option<GameEvent> {
-        let note = match key {
+        match key {
             KeyEvent::Right => {
                 if self.sequence < 6 {
                     self.sequence += 1;
@@ -112,10 +112,8 @@ impl PianoKeyboard {
             _ => notes::key_to_base_note(key, self.sequence)
                 .and_then(|note| Note::from(&note, self.color, self.sound_duration))
                 .map(GameEvent::Note),
-        };
-        note
+        }
     }
-
 }
 
 #[cfg(test)]

src/game/notes.rs

@@ -41,7 +41,7 @@ impl Note {
         for start_index in 1..note.len() {
             frequency = note[start_index..].parse();
             base_sound = note[..start_index].parse();
-            if let Ok(_) = frequency {
+            if frequency.is_ok() {
                 break;
             }
         }
@@ -76,11 +76,11 @@ impl Note {
             Some(v) => Ok(Note {
                 sound: format!("{}{}", base_sound, frequency),
                 base: base_sounds[v].to_string(),
-                frequency: frequency,
+                frequency,
                 position: init_poses[v] + 21 * ((frequency - factors[v]) as i16),
                 white: whites[v],
-                color: color,
-                duration: duration,
+                color,
+                duration,
             }),
             None => Err(String::from("We're Fucked.")),
         }

src/game/notes/play.rs

@@ -16,7 +16,7 @@ impl Player {
         for base in &["a", "as", "b", "c", "cs", "d", "ds", "e", "f", "fs", "g", "gs"] {
             for frequency in -1..8_i8 {
                 Self::read_note(*base, frequency)
-                    .and_then(|sample| {
+                    .map(|sample| {
                         samples.insert(format!("{}{}", base, frequency), sample);
                         Some(())
                     });
@@ -63,6 +63,13 @@ impl Player {
     }
 }
 
+impl Default for Player {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+
 #[cfg(test)]
 mod test {
     use super::Player;

src/game/notes_file.rs

@@ -35,11 +35,8 @@ impl NoteReader {
     pub fn parse_notes(&self) -> Vec<FileNote> {
         let mut counter = 1;
         let mut file_base_notes: Vec<FileNote> = Vec::new();
-        loop {
-            match self.parse_yaml_entry(counter) {
-                Ok(v) => file_base_notes.push(v),
-                Err(_) => break,
-            }
+        while let Ok(v) = self.parse_yaml_entry(counter) {
+            file_base_notes.push(v);
             counter += 1;
         }
         file_base_notes
@@ -54,9 +51,9 @@ impl NoteReader {
                 let base_note = x[1].as_str().unwrap();
                 let duration = Duration::from_millis(x[2].as_i64().unwrap() as u64);
                 Ok(FileNote {
-                    delay: delay,
+                    delay,
                     base_note: base_note.to_string(),
-                    duration: duration,
+                    duration,
                 })
             },
             _ => Err(String::from("Could not parse note")),
@@ -128,3 +125,10 @@ impl NoteRecorder {
         self.previous_note_time = time;
     }
 }
+
+impl Default for NoteRecorder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+

src/main.rs

@@ -74,17 +74,14 @@ fn game_loop(stdin: &mut SyncReader, keyboard: &Arc<Mutex<PianoKeyboard>>, event
 
     loop {
         if let Some(event) = stdin.next() {
-            match event {
-                InputEvent::Keyboard(key) => {
-                    match keyboard.lock().unwrap().process_key(key) {
-                        Some(GameEvent::Note(note)) => {
-                            event_sender.lock().unwrap().tick(note).unwrap();
-                        }
-                        Some(GameEvent::Quit) => break,
-                        None => { },
-                    };
-                },
-                _ => { },
+            if let InputEvent::Keyboard(key) = event {
+                match keyboard.lock().unwrap().process_key(key) {
+                    Some(GameEvent::Note(note)) => {
+                        event_sender.lock().unwrap().tick(note).unwrap();
+                    }
+                    Some(GameEvent::Quit) => break,
+                    None => { },
+                }
             }
         }
     }
@@ -163,7 +160,7 @@ fn main() -> Result<()> {
     let mut sync_stdin = input.read_sync();
 
     let cursor = cursor();
-    cursor.hide();
+    cursor.hide().unwrap_or_default();
 
     game_loop(&mut sync_stdin, &keyboard, &event_sender);
 

src/network/receiver.rs

@@ -12,7 +12,7 @@ impl Receiver {
     pub fn new(addr: SocketAddr) -> Result<Receiver> {
         let socket = UdpSocket::bind(&addr)?;
         Ok(Receiver {
-            socket: socket,
+            socket,
         })
     }
 
@@ -24,9 +24,9 @@ impl Receiver {
 
         let event: types::NetworkEvent = bincode::deserialize(&buf).unwrap();
         Ok(types::NetworkData {
-            amt: amt,
-            src: src,
-            event: event,
+            amt,
+            src,
+            event,
         })
     }
 
@@ -38,9 +38,9 @@ impl Receiver {
 
         let event: types::NetworkEvent = bincode::deserialize(&buf).unwrap();
         Ok(types::NetworkData {
-            amt: amt,
-            src: src,
-            event: event,
+            amt,
+            src,
+            event,
         })
     }
 }

src/network/sender.rs

@@ -13,8 +13,8 @@ impl Sender {
     pub fn new(addr: SocketAddr, host_addr: SocketAddr) -> Result<Sender> {
         let socket = UdpSocket::bind(&addr)?;
         Ok(Sender {
-            socket: socket,
-            host_addr: host_addr,
+            socket,
+            host_addr,
             peer_addrs: Vec::new(),
         })
     }