Fix clippy warnings

medwards · medwards · commit ef6a077f3861 · 2021-11-14T02:13:59.000+01:00
diff --git a/src/archive.rs b/src/archive.rs
@@ -1,9 +1,7 @@
-use std;
 use std::fs;
 use std::io;
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
-use zip;
 
 pub fn extract_zip<T: io::Read + io::Seek>(
     archive: &mut zip::ZipArchive<T>,
@@ -15,15 +13,15 @@ pub fn extract_zip<T: io::Read + io::Seek>(
 
         {
             let comment = file.comment();
-            if comment.len() > 0 {
+            if !comment.is_empty() {
                 println!("  File comment: {}", comment);
             }
         }
 
         let perms = convert_permissions(file.unix_mode());
 
         // also suspicious but why not?
-        if (&*file.name()).ends_with("/") {
+        if (&*file.name()).ends_with('/') {
             create_directory(&outpath, perms);
         } else {
             write_file(&mut file, &outpath, perms);
@@ -34,10 +32,7 @@ pub fn extract_zip<T: io::Read + io::Seek>(
 
 #[cfg(unix)]
 fn convert_permissions(mode: Option<u32>) -> Option<fs::Permissions> {
-    match mode {
-        Some(mode) => Some(fs::Permissions::from_mode(mode)),
-        None => None,
-    }
+    mode.map(fs::Permissions::from_mode)
 }
 #[cfg(not(unix))]
 fn convert_permissions(_mode: Option<u32>) -> Option<fs::Permissions> {
@@ -71,10 +66,7 @@ fn sanitize_filename(filename: &str) -> std::path::PathBuf {
 
     std::path::Path::new(no_null_filename)
         .components()
-        .filter(|component| match *component {
-            std::path::Component::Normal(..) => true,
-            _ => false,
-        })
+        .filter(|component| matches!(*component, std::path::Component::Normal(..)))
         .fold(std::path::PathBuf::new(), |mut path, ref cur| {
             path.push(cur.as_os_str());
             path
diff --git a/src/feed.rs b/src/feed.rs
@@ -1,9 +1,6 @@
-use csv;
-use serde;
 use std::fs::File;
 use std::path::Path;
 use tempfile::{Builder, TempDir};
-use zip;
 
 use super::archive::extract_zip;
 use super::{
@@ -41,7 +38,7 @@ impl LocalFeedProvider {
 
 impl FeedProvider for LocalFeedProvider {
     fn path(&self) -> &str {
-        return &self.path;
+        &self.path
     }
 }
 
@@ -60,7 +57,7 @@ impl ZipFeedProvider {
             zip::ZipArchive::new(File::open(zipfile).map_err(|e| Error::Feed(format!("{}", e)))?)
                 .map_err(|e| Error::Feed(format!("{}", e)))?;
         extract_zip(&mut zip, dir.path()).map_err(|e| Error::Feed(format!("{}", e)))?;
-        Ok(ZipFeedProvider { dir: dir })
+        Ok(ZipFeedProvider { dir })
     }
 }
 
@@ -85,7 +82,7 @@ impl FeedReader<ZipFeedProvider> {
 impl<P: FeedProvider> FeedReader<P> {
     pub fn from_provider(provider: P) -> Self {
         FeedReader {
-            provider: provider,
+            provider,
             builder: csv::ReaderBuilder::new(),
         }
     }
@@ -164,6 +161,6 @@ impl<P: FeedProvider> FeedReader<P> {
             Ok(reader) => reader,
             Err(e) => return Err(Error::Csv(path, e)),
         };
-        Ok(GTFSIterator::new(reader, &path)?)
+        GTFSIterator::new(reader, &path)
     }
 }
diff --git a/src/gtfs/gtfs.rs b/src/gtfs/gtfs.rs
@@ -2,8 +2,6 @@ use super::error::Error;
 use csv::{
     DeserializeError, DeserializeRecordsIntoIter, ErrorKind, Position, Reader, StringRecord,
 };
-use serde;
-use std;
 
 pub struct GTFSIterator<R, T>
 where
@@ -40,19 +38,19 @@ where
         };
         Ok(GTFSIterator {
             iter: reader.into_deserialize(),
-            headers: headers,
+            headers,
             filename: filename.to_string(),
         })
     }
 
     fn wrap_fielderror(&self, err: &DeserializeError, position: &Option<Position>) -> Error {
-        let fieldname = match err.field() {
-            Some(field_pos) => Some(match self.headers.get(field_pos as usize) {
+        let fieldname = err
+            .field()
+            .map(|field_pos| match self.headers.get(field_pos as usize) {
                 Some(field) => field.to_string(),
-                None => format!("field {}", field_pos).to_string(),
-            }),
-            None => None,
-        };
+                None => format!("field {}", field_pos),
+            });
+
         // TODO:: What if position.line() is None?
         Error::FieldError(
             String::clone(&self.filename),
diff --git a/src/gtfs/parse.rs b/src/gtfs/parse.rs
@@ -1,5 +1,4 @@
 use chrono::{Duration, NaiveDate};
-use serde;
 use serde::Deserializer;
 
 pub fn deserialize_dow_field<'de, D>(deserializer: D) -> Result<bool, D::Error>
diff --git a/src/transit.rs b/src/transit.rs
@@ -435,9 +435,9 @@ pub struct TimeOffset {
 impl TimeOffset {
     pub fn from_hms(hours: u32, minutes: u32, seconds: u32) -> TimeOffset {
         TimeOffset {
-            hours: hours,
-            minutes: minutes,
-            seconds: seconds,
+            hours,
+            minutes,
+            seconds,
         }
     }
 
diff --git a/tests/feed.rs b/tests/feed.rs
@@ -6,7 +6,7 @@ fn test_read_feed_with_reader_options() {
     feed.builder().delimiter(b';').trim(Trim::All);
 
     for result in feed.stops().unwrap() {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -15,7 +15,7 @@ fn test_read_zipfiles_with_feed() {
     let feed = FeedReader::from_zip("./examples/good_feed.zip").unwrap();
 
     for result in feed.stops().unwrap() {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
diff --git a/tests/read_gtfs.rs b/tests/read_gtfs.rs
@@ -8,7 +8,7 @@ fn test_read_agencies() {
     let iter: GTFSIterator<_, Agency> =
         GTFSIterator::from_path("./examples/good_feed/agency.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -17,7 +17,7 @@ fn test_read_stops() {
     let iter: GTFSIterator<_, Stop> =
         GTFSIterator::from_path("./examples/good_feed/stops.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -26,7 +26,7 @@ fn test_read_routes() {
     let iter: GTFSIterator<_, Route> =
         GTFSIterator::from_path("./examples/good_feed/routes.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -35,7 +35,7 @@ fn test_read_trips() {
     let iter: GTFSIterator<_, Trip> =
         GTFSIterator::from_path("./examples/good_feed/trips.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -44,7 +44,7 @@ fn test_read_stop_times() {
     let iter: GTFSIterator<_, StopTime> =
         GTFSIterator::from_path("./examples/good_feed/stop_times.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -53,7 +53,7 @@ fn test_read_calendar() {
     let iter: GTFSIterator<_, Calendar> =
         GTFSIterator::from_path("./examples/good_feed/calendar.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -62,7 +62,7 @@ fn test_read_calendar_dates() {
     let iter: GTFSIterator<_, CalendarDate> =
         GTFSIterator::from_path("./examples/good_feed/calendar_dates.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -71,7 +71,7 @@ fn test_read_fare_attributes() {
     let iter: GTFSIterator<_, FareAttribute> =
         GTFSIterator::from_path("./examples/good_feed/fare_attributes.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -80,7 +80,7 @@ fn test_read_fare_rules() {
     let iter: GTFSIterator<_, FareRule> =
         GTFSIterator::from_path("./examples/good_feed/fare_rules.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -89,7 +89,7 @@ fn test_read_shapes() {
     let iter: GTFSIterator<_, ShapePoint> =
         GTFSIterator::from_path("./examples/good_feed/shapes.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -98,7 +98,7 @@ fn test_read_frequencies() {
     let iter: GTFSIterator<_, Frequency> =
         GTFSIterator::from_path("./examples/good_feed/frequencies.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -107,7 +107,7 @@ fn test_read_transfers() {
     let iter: GTFSIterator<_, Transfer> =
         GTFSIterator::from_path("./examples/good_feed/transfers.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }
 
@@ -116,6 +116,6 @@ fn test_read_feed_info() {
     let iter: GTFSIterator<_, FeedInfo> =
         GTFSIterator::from_path("./examples/good_feed/feed_info.txt").unwrap();
     for result in iter {
-        assert!(result.is_ok(), format!("{}", result.err().unwrap()));
+        assert!(result.is_ok(), "{}", result.err().unwrap());
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,6 @@`
`1`		`-use csv;`
`2`		`-use serde;`
`3`	`1`	`use std::fs::File;`
`4`	`2`	`use std::path::Path;`
`5`	`3`	`use tempfile::{Builder, TempDir};`
`6`		`-use zip;`
`7`	`4`
`8`	`5`	`use super::archive::extract_zip;`
`9`	`6`	`use super::{`
`@@ -41,7 +38,7 @@ impl LocalFeedProvider {`
`41`	`38`
`42`	`39`	`impl FeedProvider for LocalFeedProvider {`
`43`	`40`	`fn path(&self) -> &str {`
`44`		`- return &self.path;`
	`41`	`+ &self.path`
`45`	`42`	`}`
`46`	`43`	`}`
`47`	`44`
`@@ -60,7 +57,7 @@ impl ZipFeedProvider {`
`60`	`57`	`zip::ZipArchive::new(File::open(zipfile).map_err(\|e\| Error::Feed(format!("{}", e)))?)`
`61`	`58`	`.map_err(\|e\| Error::Feed(format!("{}", e)))?;`
`62`	`59`	`extract_zip(&mut zip, dir.path()).map_err(\|e\| Error::Feed(format!("{}", e)))?;`
`63`		`- Ok(ZipFeedProvider { dir: dir })`
	`60`	`+ Ok(ZipFeedProvider { dir })`
`64`	`61`	`}`
`65`	`62`	`}`
`66`	`63`
`@@ -85,7 +82,7 @@ impl FeedReader<ZipFeedProvider> {`
`85`	`82`	`impl<P: FeedProvider> FeedReader<P> {`
`86`	`83`	`pub fn from_provider(provider: P) -> Self {`
`87`	`84`	`FeedReader {`
`88`		`- provider: provider,`
	`85`	`+ provider,`
`89`	`86`	`builder: csv::ReaderBuilder::new(),`
`90`	`87`	`}`
`91`	`88`	`}`
`@@ -164,6 +161,6 @@ impl<P: FeedProvider> FeedReader<P> {`
`164`	`161`	`Ok(reader) => reader,`
`165`	`162`	`Err(e) => return Err(Error::Csv(path, e)),`
`166`	`163`	`};`
`167`		`- Ok(GTFSIterator::new(reader, &path)?)`
	`164`	`+ GTFSIterator::new(reader, &path)`
`168`	`165`	`}`
`169`	`166`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`use chrono::{Duration, NaiveDate};`
`2`		`-use serde;`
`3`	`2`	`use serde::Deserializer;`
`4`	`3`
`5`	`4`	`pub fn deserialize_dow_field<'de, D>(deserializer: D) -> Result<bool, D::Error>`
Original file line number	Diff line number	Diff line change
`@@ -435,9 +435,9 @@ pub struct TimeOffset {`
`435`	`435`	`impl TimeOffset {`
`436`	`436`	`pub fn from_hms(hours: u32, minutes: u32, seconds: u32) -> TimeOffset {`
`437`	`437`	`TimeOffset {`
`438`		`- hours: hours,`
`439`		`- minutes: minutes,`
`440`		`- seconds: seconds,`
	`438`	`+ hours,`
	`439`	`+ minutes,`
	`440`	`+ seconds,`
`441`	`441`	`}`
`442`	`442`	`}`
`443`	`443`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ fn test_read_feed_with_reader_options() {`
`6`	`6`	`feed.builder().delimiter(b';').trim(Trim::All);`
`7`	`7`
`8`	`8`	`for result in feed.stops().unwrap() {`
`9`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`9`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`10`	`10`	`}`
`11`	`11`	`}`
`12`	`12`
`@@ -15,7 +15,7 @@ fn test_read_zipfiles_with_feed() {`
`15`	`15`	`let feed = FeedReader::from_zip("./examples/good_feed.zip").unwrap();`
`16`	`16`
`17`	`17`	`for result in feed.stops().unwrap() {`
`18`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`18`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ fn test_read_agencies() {`
`8`	`8`	`let iter: GTFSIterator<_, Agency> =`
`9`	`9`	`GTFSIterator::from_path("./examples/good_feed/agency.txt").unwrap();`
`10`	`10`	`for result in iter {`
`11`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`11`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`
`@@ -17,7 +17,7 @@ fn test_read_stops() {`
`17`	`17`	`let iter: GTFSIterator<_, Stop> =`
`18`	`18`	`GTFSIterator::from_path("./examples/good_feed/stops.txt").unwrap();`
`19`	`19`	`for result in iter {`
`20`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`20`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`@@ -26,7 +26,7 @@ fn test_read_routes() {`
`26`	`26`	`let iter: GTFSIterator<_, Route> =`
`27`	`27`	`GTFSIterator::from_path("./examples/good_feed/routes.txt").unwrap();`
`28`	`28`	`for result in iter {`
`29`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`29`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`@@ -35,7 +35,7 @@ fn test_read_trips() {`
`35`	`35`	`let iter: GTFSIterator<_, Trip> =`
`36`	`36`	`GTFSIterator::from_path("./examples/good_feed/trips.txt").unwrap();`
`37`	`37`	`for result in iter {`
`38`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`38`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`@@ -44,7 +44,7 @@ fn test_read_stop_times() {`
`44`	`44`	`let iter: GTFSIterator<_, StopTime> =`
`45`	`45`	`GTFSIterator::from_path("./examples/good_feed/stop_times.txt").unwrap();`
`46`	`46`	`for result in iter {`
`47`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`47`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`@@ -53,7 +53,7 @@ fn test_read_calendar() {`
`53`	`53`	`let iter: GTFSIterator<_, Calendar> =`
`54`	`54`	`GTFSIterator::from_path("./examples/good_feed/calendar.txt").unwrap();`
`55`	`55`	`for result in iter {`
`56`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`56`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`@@ -62,7 +62,7 @@ fn test_read_calendar_dates() {`
`62`	`62`	`let iter: GTFSIterator<_, CalendarDate> =`
`63`	`63`	`GTFSIterator::from_path("./examples/good_feed/calendar_dates.txt").unwrap();`
`64`	`64`	`for result in iter {`
`65`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`65`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`@@ -71,7 +71,7 @@ fn test_read_fare_attributes() {`
`71`	`71`	`let iter: GTFSIterator<_, FareAttribute> =`
`72`	`72`	`GTFSIterator::from_path("./examples/good_feed/fare_attributes.txt").unwrap();`
`73`	`73`	`for result in iter {`
`74`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`74`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`@@ -80,7 +80,7 @@ fn test_read_fare_rules() {`
`80`	`80`	`let iter: GTFSIterator<_, FareRule> =`
`81`	`81`	`GTFSIterator::from_path("./examples/good_feed/fare_rules.txt").unwrap();`
`82`	`82`	`for result in iter {`
`83`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`83`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`@@ -89,7 +89,7 @@ fn test_read_shapes() {`
`89`	`89`	`let iter: GTFSIterator<_, ShapePoint> =`
`90`	`90`	`GTFSIterator::from_path("./examples/good_feed/shapes.txt").unwrap();`
`91`	`91`	`for result in iter {`
`92`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`92`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`@@ -98,7 +98,7 @@ fn test_read_frequencies() {`
`98`	`98`	`let iter: GTFSIterator<_, Frequency> =`
`99`	`99`	`GTFSIterator::from_path("./examples/good_feed/frequencies.txt").unwrap();`
`100`	`100`	`for result in iter {`
`101`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`101`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`@@ -107,7 +107,7 @@ fn test_read_transfers() {`
`107`	`107`	`let iter: GTFSIterator<_, Transfer> =`
`108`	`108`	`GTFSIterator::from_path("./examples/good_feed/transfers.txt").unwrap();`
`109`	`109`	`for result in iter {`
`110`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`110`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`@@ -116,6 +116,6 @@ fn test_read_feed_info() {`
`116`	`116`	`let iter: GTFSIterator<_, FeedInfo> =`
`117`	`117`	`GTFSIterator::from_path("./examples/good_feed/feed_info.txt").unwrap();`
`118`	`118`	`for result in iter {`
`119`		`- assert!(result.is_ok(), format!("{}", result.err().unwrap()));`
	`119`	`+ assert!(result.is_ok(), "{}", result.err().unwrap());`
`120`	`120`	`}`
`121`	`121`	`}`