Fix clippy warnings

blackbeam · Jan 27, 2021 · e626775 · e626775
1 parent f6ae5ab
commit e626775
Show file tree

Hide file tree

Showing 11 changed files with 53 additions and 61 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -31,10 +31,6 @@ debug = true
 opt-level = 3
 debug = true
 
-[profile.doc]
-opt-level = 0
-debug = false
-
 [features]
 default = []
 nightly = []
diff --git a/src/directory.rs b/src/directory.rs
@@ -20,7 +20,7 @@ impl Directory {
                 return Err(Error::UnexpectedEofInDirectory);
             }
         }
-        Ok(Directory { entries: entries })
+        Ok(Directory { entries })
     }
 }
 

diff --git a/src/field/fields.rs b/src/field/fields.rs
@@ -9,10 +9,7 @@ pub struct Fields<'a> {
 impl<'a> Fields<'a> {
     #[doc(hidden)]
     pub fn new(record: &'a Record<'a>) -> Fields<'a> {
-        Fields {
-            record: record,
-            offset: 0,
-        }
+        Fields { record, offset: 0 }
     }
 }
 

diff --git a/src/field/mod.rs b/src/field/mod.rs
@@ -14,15 +14,12 @@ pub struct Field<'a> {
 
 impl<'a> Field<'a> {
     #[doc(hidden)]
-    pub fn new<'x>(tag: Tag, data: &'x [u8]) -> Field<'x> {
-        Field {
-            tag: tag,
-            data: data,
-        }
+    pub fn new(tag: Tag, data: &[u8]) -> Field<'_> {
+        Field { tag, data }
     }
 
     /// Will find all subfields with identifier `ident`.
-    pub fn subfield<'r, Ident: Into<Identifier>>(&'r self, ident: Ident) -> Vec<Subfield<'r>> {
+    pub fn subfield<Ident: Into<Identifier>>(&self, ident: Ident) -> Vec<Subfield<'_>> {
         Subfield::find(self, ident)
     }
 

diff --git a/src/field/subfield/mod.rs b/src/field/subfield/mod.rs
@@ -28,7 +28,7 @@ impl<'a> Subfield<'a> {
                 output.push(sf);
             }
         }
-        return output;
+        output
     }
 
     /// Returns tag of a field this subfield belongs to.

diff --git a/src/field/subfield/subfields.rs b/src/field/subfield/subfields.rs
@@ -29,7 +29,7 @@ impl<'a> Iterator for Subfields<'a> {
                 self.state = State::Start(2);
                 self.next()
             }
-            State::Start(offset) => match self.field.data.get(offset).map(|x| *x) {
+            State::Start(offset) => match self.field.data.get(offset).copied() {
                 Some(SUBFIELD_DELIMITER) => {
                     self.state = State::SubfieldStart(offset + 1);
                     self.next()
@@ -40,7 +40,7 @@ impl<'a> Iterator for Subfields<'a> {
                 }
             },
             State::SubfieldStart(offset) => {
-                match self.field.data.get(offset).map(|x| *x) {
+                match self.field.data.get(offset).copied() {
                     Some(SUBFIELD_DELIMITER) | None => {
                         // Subfield ends unexpectedly
                         self.state = State::Done;
@@ -53,7 +53,7 @@ impl<'a> Iterator for Subfields<'a> {
                 }
             }
             State::Subfield(identifier, start, offset) => {
-                match self.field.data.get(start + offset).map(|x| *x) {
+                match self.field.data.get(start + offset).copied() {
                     Some(SUBFIELD_DELIMITER) => {
                         self.state = State::SubfieldStart(start + offset + 1);
                         Some(Subfield {

diff --git a/src/identifier.rs b/src/identifier.rs
@@ -2,9 +2,9 @@
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
 pub struct Identifier(pub u8);
 
-impl Into<u8> for Identifier {
-    fn into(self) -> u8 {
-        self.0
+impl From<Identifier> for u8 {
+    fn from(x: Identifier) -> Self {
+        x.0
     }
 }
 

diff --git a/src/indicator.rs b/src/indicator.rs
@@ -2,8 +2,8 @@
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
 pub struct Indicator(pub [u8; 2]);
 
-impl Indicator {
-    pub fn as_ref(&self) -> &[u8] {
+impl AsRef<[u8]> for Indicator {
+    fn as_ref(&self) -> &[u8] {
         &self.0[..]
     }
 }

diff --git a/src/lib.rs b/src/lib.rs
@@ -68,7 +68,7 @@ impl<'a> Record<'a> {
     /// Will try to parse record from a buffer.
     ///
     /// Will borrow an `input` for the lifetime of a produced record.
-    pub fn parse<'x>(input: &'x [u8]) -> Result<Record<'x>> {
+    pub fn parse(input: &[u8]) -> Result<Record<'_>> {
         let len = misc::read_dec_5(input)?;
         if input.len() < len {
             return Err(Error::UnexpectedEof);
@@ -84,8 +84,8 @@ impl<'a> Record<'a> {
 
         Ok(Record {
             data: Cow::Borrowed(data),
-            data_offset: data_offset,
-            directory: directory,
+            data_offset,
+            directory,
         })
     }
 
@@ -111,8 +111,8 @@ impl<'a> Record<'a> {
 
         Ok(Record {
             data: Cow::Owned(input),
-            data_offset: data_offset,
-            directory: directory,
+            data_offset,
+            directory,
         })
     }
 
@@ -122,9 +122,8 @@ impl<'a> Record<'a> {
     pub fn read<T: io::Read>(input: &mut T) -> Result<Option<Record<'static>>> {
         let mut data = vec![0; 5];
 
-        match input.read(&mut data[..1])? {
-            0 => return Ok(None),
-            _ => (),
+        if let 0 = input.read(&mut data[..1])? {
+            return Ok(None);
         }
 
         input.read_exact(&mut data[1..])?;
@@ -144,8 +143,8 @@ impl<'a> Record<'a> {
 
         Ok(Some(Record {
             data: Cow::Owned(data),
-            data_offset: data_offset,
-            directory: directory,
+            data_offset,
+            directory,
         }))
     }
 
@@ -163,15 +162,10 @@ impl<'a> Record<'a> {
     }
 
     /// Will return iterator over fields of a record
-    pub fn fields<'r>(&'r self) -> Fields<'r> {
+    pub fn fields(&self) -> Fields<'_> {
         Fields::new(self)
     }
 
-    /// View into a data of a record.
-    pub fn as_ref(&self) -> &[u8] {
-        self.data.borrow()
-    }
-
     get!(RecordStatus, record_status, 5);
     get!(TypeOfRecord, type_of_record, 6);
     get!(BibliographicLevel, bibliographic_level, 7);
@@ -186,6 +180,12 @@ impl<'a> Record<'a> {
     );
 }
 
+impl AsRef<[u8]> for Record<'_> {
+    fn as_ref(&self) -> &[u8] {
+        self.data.borrow()
+    }
+}
+
 impl<'a> fmt::Display for Record<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(
@@ -291,11 +291,8 @@ impl RecordBuilder {
     pub fn from_record(record: &Record) -> RecordBuilder {
         let mut leader = [0; 24];
         leader.copy_from_slice(&record.as_ref()[0..24]);
-        let fields = record.fields().map(|f| FieldRepr::from(f)).collect();
-        RecordBuilder {
-            leader: leader,
-            fields: fields,
-        }
+        let fields = record.fields().map(FieldRepr::from).collect();
+        RecordBuilder { leader, fields }
     }
 
     /// Iterator over fields of this builder.
@@ -385,7 +382,7 @@ impl RecordBuilder {
         }
 
         // writing record length
-        &mut data[0..5].copy_from_slice(format!("{:05}", size).as_bytes());
+        data[0..5].copy_from_slice(format!("{:05}", size).as_bytes());
 
         // writing directory
         let mut offset = 0;
@@ -400,7 +397,7 @@ impl RecordBuilder {
 
         // writing base address of data
         let len = data.len();
-        &mut data[12..17].copy_from_slice(format!("{:05}", len).as_bytes());
+        data[12..17].copy_from_slice(format!("{:05}", len).as_bytes());
 
         // writing fields
         for f in self.fields.iter() {
@@ -421,8 +418,8 @@ impl RecordBuilder {
 
         Ok(Record {
             data: Cow::Owned(data),
-            data_offset: data_offset,
-            directory: directory,
+            data_offset,
+            directory,
         })
     }
 
@@ -456,6 +453,12 @@ impl RecordBuilder {
     );
 }
 
+impl Default for RecordBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 macro_rules! leader_field(
     ($name:ident {
         $($val:expr => $kind:ident,)+
@@ -476,10 +479,10 @@ macro_rules! leader_field(
             }
         }
 
-        impl Into<u8> for $name {
+        impl From<$name> for u8 {
             #[inline]
-            fn into(self) -> u8 {
-                match self {
+            fn from(x: $name) -> u8 {
+                match x {
                     $($name::$kind => $val),+,
                     $name::Unknown(b) => b,
                 }
@@ -1070,7 +1073,6 @@ mod tests {
 
     mod write {
         use super::{super::*, RECS};
-        use std::error::Error;
 
         #[test]
         fn should_write_record() {
@@ -1079,7 +1081,7 @@ mod tests {
             let record = Record::parse(&RECS.as_bytes()[..963]).unwrap();
 
             match vec.write_record(record.clone()) {
-                Err(why) => panic!("couldn't write file: {}", why.description()),
+                Err(why) => panic!("couldn't write file: {}", why),
                 Ok(_) => (),
             }
 

diff --git a/src/misc.rs b/src/misc.rs
@@ -1,7 +1,7 @@
 use crate::errors::*;
 
 pub fn read_dec_1(i: u8) -> Result<u8> {
-    if 0x30 > i || i > 0x39 {
+    if !(0x30..=0x39).contains(&i) {
         Err(Error::UnexpectedByteInDecNum(i))
     } else {
         Ok(0x0F & i)
@@ -13,8 +13,8 @@ pub fn read_dec_4(i: &[u8]) -> Result<usize> {
         return Err(Error::UnexpectedEofInDecNum);
     }
     let mut result = 0usize;
-    for x in 0..4usize {
-        result += 10usize.pow(3 - x as u32) * read_dec_1(i[x])? as usize;
+    for (x, byte) in i.iter().enumerate().take(4) {
+        result += 10_usize.pow(3 - x as u32) * read_dec_1(*byte)? as usize;
     }
     Ok(result)
 }
@@ -24,8 +24,8 @@ pub fn read_dec_5(i: &[u8]) -> Result<usize> {
         return Err(Error::UnexpectedEofInDecNum);
     }
     let mut result = 0usize;
-    for x in 0..5usize {
-        result += 10usize.pow(4 - x as u32) * read_dec_1(i[x])? as usize;
+    for (x, byte) in i.iter().enumerate().take(5) {
+        result += 10_usize.pow(4 - x as u32) * read_dec_1(*byte)? as usize;
     }
     Ok(result)
 }
diff --git a/src/tag.rs b/src/tag.rs
@@ -4,8 +4,8 @@ use std::{fmt, str};
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
 pub struct Tag(pub [u8; 3]);
 
-impl Tag {
-    pub fn as_ref(&self) -> &[u8] {
+impl AsRef<[u8]> for Tag {
+    fn as_ref(&self) -> &[u8] {
         &self.0[..]
     }
 }