style: fix clippy issues

Author: piperRyan

src/integrations/duration.rs

@@ -12,12 +12,12 @@ impl 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); 
+        new_dur -= Duration::hours(hours); 
         let minutes = new_dur.num_minutes(); 
-        new_dur = new_dur - Duration::minutes(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;  

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;

src/interval_parse/iso_8601.rs

@@ -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.",
             ))
@@ -104,7 +104,7 @@ 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_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]

src/interval_parse/postgres.rs

@@ -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,7 @@ 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);
     }
 

src/pg_interval_add.rs

@@ -96,7 +96,7 @@ mod tests {
     #[test]
     fn test_checked_add_2() {
         let interval = Interval::new(13, 0, 0);
-        let interval_add = Interval::new(i32::max_value(), 1, 12);
+        let interval_add = Interval::new(i32::MAX, 1, 12);
         let result = interval.checked_add(interval_add);
         assert_eq!(result, None);
     }
@@ -110,7 +110,7 @@ mod tests {
 
     #[test]
     fn test_checked_add_day_time_2() {
-        let interval = Interval::new(13, i32::max_value(), 0);
+        let interval = Interval::new(13, i32::MAX, 0);
         let result = interval.checked_add_day_time(200, 0, 0, 2.123456789);
         assert_eq!(result, None);
     }
@@ -132,7 +132,7 @@ mod tests {
     #[test]
     fn checked_add_year_month_2() {
         let interval = Interval::new(15, 0, 0);
-        let result = interval.checked_add_year_month(i32::max_value(), 32);
+        let result = interval.checked_add_year_month(i32::MAX, 32);
         assert_eq!(result, None);
     }
 

src/pg_interval_sub.rs

@@ -104,7 +104,7 @@ mod tests {
 
     #[test]
     fn test_checked_sub_day_time_2() {
-        let interval = Interval::new(13, i32::min_value(), 0);
+        let interval = Interval::new(13, i32::MIN, 0);
         println!("{:?}", interval.days);
         let result = interval.checked_sub_day_time(100, 0, 0, 2.12);
         println!("{:?}", result);
@@ -128,7 +128,7 @@ mod tests {
     #[test]
     fn test_checked_sub_year_month_2() {
         let interval = Interval::new(-20, 0, 0);
-        let result = interval.checked_sub_year_month(i32::min_value(), 1);
+        let result = interval.checked_sub_year_month(i32::MIN, 1);
         assert_eq!(result, None);
     }
 
@@ -151,7 +151,7 @@ mod tests {
     #[test]
     fn test_checked_sub_2() {
         let interval = Interval::new(-10, 0, 0);
-        let interval_sub = Interval::new(i32::max_value(), 0, 0);
+        let interval_sub = Interval::new(i32::MAX, 0, 0);
         let result = interval.checked_sub(interval_sub);
         assert_eq!(result, None);
     }