cosmetic changes

Author: rizsotto

src/iterator.rs

@@ -27,9 +27,8 @@ where
     R: io::Read,
 {
     match state {
-        State::AtStart => {
-            if read_skipping_ws(&mut reader)? == b'[' {
-                // read the next char to see if the array is empty
+        State::AtStart => match read_skipping_ws(&mut reader)? {
+            b'[' => {
                 let peek = read_skipping_ws(&mut reader)?;
                 if peek == b']' {
                     *state = State::Finished;
@@ -38,11 +37,12 @@ where
                     *state = State::AtMiddle;
                     deserialize_single(io::Cursor::new([peek]).chain(reader)).map(Some)
                 }
-            } else {
+            }
+            _ => {
                 *state = State::Failed;
                 Err(serde::de::Error::custom("expected `[`"))
             }
-        }
+        },
         State::AtMiddle => match read_skipping_ws(&mut reader)? {
             b',' => deserialize_single(reader).map(Some),
             b']' => {
@@ -54,8 +54,7 @@ where
                 Err(serde::de::Error::custom("expected `,` or `]`"))
             }
         },
-        State::Finished => Ok(None),
-        State::Failed => Ok(None),
+        State::Finished | State::Failed => Ok(None),
     }
 }
 
@@ -74,9 +73,10 @@ where
 fn read_skipping_ws(mut reader: impl io::Read) -> Result<u8> {
     loop {
         let mut byte = 0u8;
-        if let Err(io) = reader.read_exact(std::slice::from_mut(&mut byte)) {
-            return Err(Error::io(io));
-        }
+        reader
+            .read_exact(std::slice::from_mut(&mut byte))
+            .map_err(Error::io)?;
+
         if !byte.is_ascii_whitespace() {
             return Ok(byte);
         }

src/lib.rs

@@ -43,6 +43,7 @@ pub struct Entry {
     pub output: Option<std::path::PathBuf>,
 }
 
+/// Serialize entries from the iterator into a Writer object.
 pub fn write(
     writer: impl std::io::Write,
     entries: impl Iterator<Item = Entry>,
@@ -55,6 +56,7 @@ pub fn write(
     seq.end()
 }
 
+/// Deserialize entries from the Reader object into an iterator of Entries.
 pub fn read(reader: impl std::io::Read) -> impl Iterator<Item = Result<Entry, Error>> {
     iterator::iter_json_array(reader)
 }

src/type_de.rs

@@ -74,36 +74,11 @@ impl<'de> Deserialize<'de> for Entry {
 
                 while let Some(key) = map.next_key()? {
                     match key {
-                        Field::Directory => {
-                            if directory.is_some() {
-                                return Err(de::Error::duplicate_field("directory"));
-                            }
-                            directory = Some(map.next_value()?);
-                        }
-                        Field::File => {
-                            if file.is_some() {
-                                return Err(de::Error::duplicate_field("file"));
-                            }
-                            file = Some(map.next_value()?);
-                        }
-                        Field::Command => {
-                            if command.is_some() {
-                                return Err(de::Error::duplicate_field("command"));
-                            }
-                            command = Some(map.next_value()?);
-                        }
-                        Field::Arguments => {
-                            if arguments.is_some() {
-                                return Err(de::Error::duplicate_field("arguments"));
-                            }
-                            arguments = Some(map.next_value()?);
-                        }
-                        Field::Output => {
-                            if output.is_some() {
-                                return Err(de::Error::duplicate_field("output"));
-                            }
-                            output = Some(map.next_value()?);
-                        }
+                        Field::Directory => directory = Some(map.next_value()?),
+                        Field::File => file = Some(map.next_value()?),
+                        Field::Command => command = Some(map.next_value()?),
+                        Field::Arguments => arguments = Some(map.next_value()?),
+                        Field::Output => output = Some(map.next_value()?),
                     }
                 }
                 let directory = directory.ok_or_else(|| de::Error::missing_field("directory"))?;