style: fix clippy issues

Author: piperRyan

src/integrations/duration.rs

@@ -5,22 +5,22 @@ const NANOS_PER_SEC: i64 = 1_000_000_000;
 const NANOS_PER_MICRO: i64 = 1000;
 
 impl Interval {
-    /// Tries to convert from the `Duration` type to a `Interval`. Will 
-    /// return `None` on a overflow. This is a lossy conversion in that 
+    /// Tries to convert from the `Duration` type to a `Interval`. Will
+    /// return `None` on a overflow. This is a lossy conversion in that
     /// any units smaller than a microsecond will be lost.   
     pub fn from_duration(duration: Duration) -> Option<Interval> {
-        let mut days = duration.num_days(); 
-        let mut new_dur = duration - Duration::days(days); 
-        let mut hours = duration.num_hours(); 
-        new_dur = new_dur - Duration::hours(hours); 
-        let minutes = new_dur.num_minutes(); 
-        new_dur = new_dur - Duration::minutes(minutes); 
+        let mut days = duration.num_days();
+        let mut new_dur = duration - Duration::days(days);
+        let mut hours = duration.num_hours();
+        new_dur -= Duration::hours(hours);
+        let minutes = new_dur.num_minutes();
+        new_dur -= Duration::minutes(minutes);
         let nano_secs = new_dur.num_nanoseconds()?;
-        if days > (i32::max_value() as i64) {
-            let overflow_days = days - (i32::max_value() as i64);
+        if days > (i32::MAX as i64) {
+            let overflow_days = days - (i32::MAX as i64);
             let added_hours = overflow_days.checked_mul(24)?;
-            hours = hours.checked_add(added_hours)?;  
-            days -= overflow_days;  
+            hours = hours.checked_add(added_hours)?;
+            days -= overflow_days;
         }
         let (seconds, remaining_nano) = reduce_by_units(nano_secs, NANOS_PER_SEC);
         // We have to discard any remaining nanoseconds
@@ -39,22 +39,21 @@ impl Interval {
 }
 
 fn reduce_by_units(nano_secs: i64, unit: i64) -> (i64, i64) {
-    let new_time_unit = (nano_secs - (nano_secs % unit)) / unit; 
+    let new_time_unit = (nano_secs - (nano_secs % unit)) / unit;
     let remaining_nano = nano_secs - (new_time_unit * unit);
-    (new_time_unit, remaining_nano)   
+    (new_time_unit, remaining_nano)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use chrono::Duration;
 
-
     #[test]
     fn can_convert_small_amount_of_days() {
         let dur = Duration::days(5);
         let interval = Interval::from_duration(dur);
-        assert_eq!(interval, Some(Interval::new(0,5,0)))
+        assert_eq!(interval, Some(Interval::new(0, 5, 0)))
     }
 
     #[test]
@@ -68,13 +67,13 @@ mod tests {
     fn can_convert_small_amount_of_secs() {
         let dur = Duration::seconds(1);
         let interval = Interval::from_duration(dur);
-        assert_eq!(interval, Some(Interval::new(0,0,1_000_000)))
+        assert_eq!(interval, Some(Interval::new(0, 0, 1_000_000)))
     }
 
     #[test]
     fn can_convert_one_micro() {
         let dur = Duration::nanoseconds(1000);
         let interval = Interval::from_duration(dur);
-        assert_eq!(interval, Some(Interval::new(0,0,1)))
+        assert_eq!(interval, Some(Interval::new(0, 0, 1)))
     }
-}
+}

src/integrations/mod.rs

@@ -1,2 +1,2 @@
+mod duration;
 mod rust_postgres;
-mod duration; 

src/integrations/rust_postgres.rs

@@ -1,7 +1,7 @@
 use crate::Interval;
 use bytes::{Buf, BufMut, BytesMut};
-use std::error::Error;
 use postgres_types::{to_sql_checked, FromSql, IsNull, ToSql, Type};
+use std::error::Error;
 
 impl<'a> FromSql<'a> for Interval {
     fn from_sql(_: &Type, mut raw: &'a [u8]) -> Result<Self, Box<dyn Error + Sync + Send>> {

src/interval_fmt/iso_8601.rs

@@ -36,8 +36,8 @@ impl IntervalNorm {
         if self.days != 0 {
             day_interval.push_str(&format!("{}D", self.days));
         }
-        year_interval.push_str(&*day_interval);
-        year_interval.push_str(&*time_interval);
+        year_interval.push_str(&day_interval);
+        year_interval.push_str(&time_interval);
         year_interval
     }
 }

src/interval_fmt/mod.rs

@@ -7,30 +7,30 @@ use std::ops::Neg;
 /// Safely maps a i64 value to a unsigned number
 /// without any overflow issues.
 fn safe_abs_u64(mut num: i64) -> u64 {
-    let max = i64::max_value();
+    let max = i64::MAX;
     let max_min = max.neg();
     if num <= max_min {
         let result = max as u64;
         num += max;
         num *= -1;
         result + num as u64
     } else {
-        num.abs() as u64
+        num.unsigned_abs()
     }
 }
 
 /// Safely maps a i32 value to a unsigned number
 /// without any overflow issues.
 fn safe_abs_u32(mut num: i32) -> u32 {
-    let max = i32::max_value();
+    let max = i32::MAX;
     let max_min = max.neg();
     if num <= max_min {
         let result = max as u32;
         num += max;
         num *= -1;
         result + num as u32
     } else {
-        num.abs() as u32
+        num.unsigned_abs()
     }
 }
 
@@ -41,7 +41,7 @@ fn pad_i64(val: i64) -> String {
     } else {
         val as u64
     };
-    return format!("{:02}", num);
+    format!("{:02}", num)
 }
 
 #[cfg(test)]
@@ -50,15 +50,15 @@ mod tests {
 
     #[test]
     fn abs_safe_u32() {
-        let min = i32::min_value();
+        let min = i32::MIN;
         let actual = safe_abs_u32(min);
         let expected = 2147483648;
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn abs_safe_u64() {
-        let min = i64::min_value();
+        let min = i64::MIN;
         let actual = safe_abs_u64(min);
         let expected = 9_223_372_036_854_775_808;
         assert_eq!(actual, expected);

src/interval_fmt/postgres.rs

@@ -14,14 +14,14 @@ impl IntervalNorm {
         }
         if self.is_year_month_present() {
             if self.years != 0 {
-                year_interval.push_str(&*format!("{:#?} year ", self.years))
+                year_interval.push_str(&format!("{:#?} year ", self.years))
             }
             if self.months != 0 {
-                year_interval.push_str(&*format!("{:#?} mons ", self.months));
+                year_interval.push_str(&format!("{:#?} mons ", self.months));
             }
         }
-        year_interval.push_str(&*day_interval);
-        year_interval.push_str(&*time_interval);
+        year_interval.push_str(&day_interval);
+        year_interval.push_str(&time_interval);
         year_interval.trim().to_owned()
     }
 
@@ -35,15 +35,15 @@ impl IntervalNorm {
             };
             let hours = super::pad_i64(self.hours);
             time_interval.push_str(
-                &*(sign
+                &(sign
                     + &hours
                     + ":"
                     + &super::pad_i64(self.minutes)
                     + ":"
                     + &super::pad_i64(self.seconds)),
             );
             if self.microseconds != 0 {
-                time_interval.push_str(&*format!(".{:06}", super::safe_abs_u64(self.microseconds)))
+                time_interval.push_str(&format!(".{:06}", super::safe_abs_u64(self.microseconds)))
             }
         }
         time_interval

src/interval_norm.rs

@@ -10,7 +10,7 @@ pub struct IntervalNorm {
     pub microseconds: i64,
 }
 
-impl<'a> From<&'a Interval> for IntervalNorm {
+impl From<&Interval> for IntervalNorm {
     fn from(val: &Interval) -> IntervalNorm {
         // grab the base values from the interval
         let months = val.months;
@@ -62,7 +62,7 @@ impl IntervalNorm {
             })?,
             days: self.days,
             microseconds: microseconds
-            .ok_or_else(|| ParseError::from_time("Invalid time interval overflow detected."))?,
+                .ok_or_else(|| ParseError::from_time("Invalid time interval overflow detected."))?,
         })
     }
 

src/interval_parse/iso_8601.rs

@@ -1,8 +1,8 @@
+use super::parse_error::ParseError;
 use super::{
     scale_date, scale_time, DAYS_PER_MONTH, HOURS_PER_DAY, MICROS_PER_SECOND, MINUTES_PER_HOUR,
     MONTHS_PER_YEAR, SECONDS_PER_MIN,
 };
-use super::parse_error::ParseError;
 use crate::{interval_norm::IntervalNorm, Interval};
 
 enum ParserCode {
@@ -17,7 +17,7 @@ impl Interval {
         let delim = vec!['Y', 'M', 'D', 'H', 'S'];
         let mut number = String::new();
         let mut interval_norm = IntervalNorm::default();
-        if iso_str.rfind('P').map_or(false, |v| v == 1) {
+        if iso_str.rfind('P') == Some(1) {
             Err(ParseError::from_invalid_interval(
                 "Invalid format must start with P.",
             ))
@@ -102,9 +102,9 @@ impl Interval {
 }
 
 fn consume_number<'a>(val: &'a char, number: &'a mut String, delim: &[char]) -> ParserCode {
-    let is_first_char = number.is_empty() && *val == '-'; 
+    let is_first_char = number.is_empty() && *val == '-';
     let is_period_char = !number.is_empty() && *val == '.';
-    if val.is_digit(10) || is_first_char || is_period_char {
+    if val.is_ascii_digit() || is_first_char || is_period_char {
         number.push(*val);
         ParserCode::Good
     } else if delim.contains(val) {
@@ -116,7 +116,7 @@ fn consume_number<'a>(val: &'a char, number: &'a mut String, delim: &[char]) ->
 
 fn parse_number(number: &mut String) -> Result<f64, ParseError> {
     let parse_num = number.parse::<f64>()?;
-    if parse_num > i32::max_value() as f64 {
+    if parse_num > i32::MAX as f64 {
         Err(ParseError::from_invalid_interval("Exceeded max value"))
     } else {
         *number = "".to_owned();
@@ -257,19 +257,19 @@ mod tests {
     #[test]
     fn test_from_8601_19() {
         let interval = Interval::from_iso("PTT");
-        assert_eq!(interval.is_err(), true);
+        assert!(interval.is_err());
     }
 
     #[test]
     fn test_from_8601_20() {
         let interval = Interval::from_iso("PT-");
-        assert_eq!(interval.is_err(), true);
+        assert!(interval.is_err());
     }
 
     #[test]
     fn test_from_8601_21() {
         let interval = Interval::from_iso("PT10");
-        assert_eq!(interval.is_err(), true);
+        assert!(interval.is_err());
     }
 
     #[test]
@@ -299,5 +299,4 @@ mod tests {
         let interval_exp = Interval::new(0, 0, 10000000);
         assert_eq!(interval, interval_exp);
     }
-
 }

src/interval_parse/postgres.rs

@@ -7,11 +7,11 @@ use super::{
 };
 
 impl Interval {
-     pub fn from_postgres(iso_str: &str) -> Result<Interval, ParseError> {
+    pub fn from_postgres(iso_str: &str) -> Result<Interval, ParseError> {
         let mut delim = vec![
             "years", "months", "mons", "days", "hours", "minutes", "seconds",
         ];
-        let mut time_tokens = iso_str.split(' ').collect::<Vec<&str>>();        // clean up empty values caused by n spaces between values.
+        let mut time_tokens = iso_str.split(' ').collect::<Vec<&str>>(); // clean up empty values caused by n spaces between values.
         time_tokens.retain(|&token| !token.is_empty());
         // since there might not be space between the delim and the
         // value we need to scan each token.
@@ -88,11 +88,11 @@ fn split_token(val: &str) -> Result<(String, String), ParseError> {
 }
 
 /// Consume the token parts and add to the normalized interval.
-fn consume_token<'a>(
+fn consume_token(
     interval: &mut IntervalNorm,
     val: f64,
     delim: String,
-    delim_list: &mut Vec<&'a str>,
+    delim_list: &mut Vec<&str>,
 ) -> Result<(), ParseError> {
     // Unlike iso8601 the delimiter can only appear once
     // so we need to check if the token can be found in
@@ -325,19 +325,19 @@ mod tests {
     #[test]
     fn test_from_postgres_24() {
         let interval = Interval::from_postgres("years 1");
-        assert_eq!(interval.is_err(), true);
+        assert!(interval.is_err());
     }
 
     #[test]
     fn test_from_postgres_25() {
         let interval = Interval::from_postgres("- years");
-        assert_eq!(interval.is_err(), true);
+        assert!(interval.is_err());
     }
 
     #[test]
     fn test_from_postgres_26() {
         let interval = Interval::from_postgres("10");
-        assert_eq!(interval.is_err(), true);
+        assert!(interval.is_err());
     }
 
     #[test]
@@ -364,7 +364,6 @@ mod tests {
     #[test]
     fn test_from_postgres_30() {
         let interval = Interval::from_postgres("!");
-        assert_eq!(interval.is_err(), true);
+        assert!(interval.is_err());
     }
-
 }

src/pg_interval.rs

@@ -56,7 +56,7 @@ mod tests {
     #[test]
     fn test_clone() {
         let interval = Interval::new(1, 1, 30);
-        let test_interval = interval.clone();
+        let test_interval = interval;
         assert_eq!(interval, test_interval);
     }
 
@@ -313,7 +313,7 @@ mod tests {
     }
 
     #[test]
-    fn test_postgres_19(){
+    fn test_postgres_19() {
         let interval = Interval::new(0, 3, 0);
         let output = interval.to_postgres();
         assert_eq!(String::from("3 days"), output);
@@ -444,5 +444,4 @@ mod tests {
         let output = interval.to_sql();
         assert_eq!(String::from("-1:10:15"), output);
     }
-
 }