lint

sfavot · joelwurtz · commit 707c469c3b33 · 2023-03-15T15:01:13.000+01:00
diff --git a/src/api/rule.rs b/src/api/rule.rs
@@ -1,7 +1,8 @@
-use crate::api::{BodyFilter, Example, HeaderFilter, IpConstraint, DateTimeConstraint, Marker, Source, Variable};
+use crate::api::{BodyFilter, DateTimeConstraint, Example, HeaderFilter, IpConstraint, Marker, Source, Variable};
 use crate::http::Request;
 use crate::router::{
-    Marker as RouteMarker, MarkerString, Route, RouteData, RouteHeader, RouteHeaderKind, RouteIp, RouteDateTime, RouteTime, RouteWeekday, RouterConfig, StaticOrDynamic, Transform,
+    Marker as RouteMarker, MarkerString, Route, RouteData, RouteDateTime, RouteHeader, RouteHeaderKind, RouteIp, RouteTime, RouteWeekday,
+    RouterConfig, StaticOrDynamic, Transform,
 };
 use cidr::AnyIpCidr;
 use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
diff --git a/src/api/source.rs b/src/api/source.rs
@@ -1,4 +1,4 @@
-use crate::api::{Header, IpConstraint, DateTimeConstraint};
+use crate::api::{DateTimeConstraint, Header, IpConstraint};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
diff --git a/src/http/request.rs b/src/http/request.rs
@@ -187,16 +187,12 @@ impl Request {
     pub fn set_created_at(&mut self, created_at: Option<String>) {
         match created_at {
             None => (),
-            Some(created_at) => {
-                match created_at.parse::<DateTime<Utc>>() {
-                    Ok(dt) => {
-                        self.created_at = Some(dt)
-                    },
-                    Err(err) => {
-                        log::error!("cannot parse datetime {}: {}", created_at, err);
-                    }
+            Some(created_at) => match created_at.parse::<DateTime<Utc>>() {
+                Ok(dt) => self.created_at = Some(dt),
+                Err(err) => {
+                    log::error!("cannot parse datetime {}: {}", created_at, err);
                 }
-            }
+            },
         };
     }
 
diff --git a/src/router/mod.rs b/src/router/mod.rs
@@ -13,7 +13,7 @@ mod transformer;
 use crate::http::Request;
 pub use config::RouterConfig;
 pub use marker_string::{Marker, MarkerString, StaticOrDynamic};
-pub use request_matcher::{HostMatcher, IpMatcher, DateTimeMatcher, MethodMatcher, PathAndQueryMatcher, RequestMatcher, SchemeMatcher};
+pub use request_matcher::{DateTimeMatcher, HostMatcher, IpMatcher, MethodMatcher, PathAndQueryMatcher, RequestMatcher, SchemeMatcher};
 pub use route::{Route, RouteData};
 pub use route_datetime::RouteDateTime;
 pub use route_header::{RouteHeader, RouteHeaderKind};
diff --git a/src/router/request_matcher/datetime.rs b/src/router/request_matcher/datetime.rs
@@ -232,22 +232,22 @@ impl<T: RouteData> DateTimeMatcher<T> {
 impl DateTimeCondition {
     pub fn match_value(&self, datetime: &DateTime<Utc>) -> bool {
         match self {
-            DateTimeCondition::DateTimeRange(route_date_time) =>  {
+            DateTimeCondition::DateTimeRange(route_date_time) => {
                 for range in route_date_time {
                     if range.match_datetime(datetime) {
                         return true;
                     }
                 }
                 return false;
-            },
+            }
             DateTimeCondition::TimeRange(route_time) => {
                 for range in route_time {
                     if range.match_datetime(datetime) {
                         return true;
                     }
                 }
                 return false;
-            },
+            }
             DateTimeCondition::Weekdays(route_weekday) => route_weekday.match_datetime(datetime),
         }
     }
diff --git a/src/router/request_matcher/mod.rs b/src/router/request_matcher/mod.rs
@@ -12,7 +12,7 @@ use crate::http::Request;
 use crate::router::{Route, RouteData, Trace};
 use std::fmt::Debug;
 
-pub use datetime::{DateTimeMatcher, DateTimeCondition};
+pub use datetime::{DateTimeCondition, DateTimeMatcher};
 pub use header::{HeaderMatcher, ValueCondition as HeaderValueCondition};
 pub use host::HostMatcher;
 pub use ip::IpMatcher;
diff --git a/src/router/route_datetime.rs b/src/router/route_datetime.rs
@@ -1,5 +1,5 @@
+use chrono::{DateTime, NaiveDateTime, Utc};
 use serde::{Deserialize, Serialize};
-use chrono::{NaiveDateTime, DateTime, Utc};
 
 #[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
 pub struct RouteDateTime {
@@ -8,33 +8,26 @@ pub struct RouteDateTime {
 }
 
 impl RouteDateTime {
-    pub fn from_range(
-        start: &Option<String>,
-        end: &Option<String>,
-    ) -> RouteDateTime {
+    pub fn from_range(start: &Option<String>, end: &Option<String>) -> RouteDateTime {
         let mut route_start = None;
         let mut route_end = None;
         match start {
             None => (),
-            Some(datetime) => {
-                match datetime.parse::<DateTime<Utc>>() {
-                    Ok(dt) => route_start = Some(dt.naive_utc()),
-                    Err(err) => {
-                        log::error!("cannot parse datetime {}: {}", datetime, err);
-                    }
+            Some(datetime) => match datetime.parse::<DateTime<Utc>>() {
+                Ok(dt) => route_start = Some(dt.naive_utc()),
+                Err(err) => {
+                    log::error!("cannot parse datetime {}: {}", datetime, err);
                 }
-            }
+            },
         }
         match end {
             None => (),
-            Some(datetime) => {
-                match datetime.parse::<DateTime<Utc>>() {
-                    Ok(dt) => route_end = Some(dt.naive_utc()),
-                    Err(err) => {
-                        log::error!("cannot parse datetime {}: {}", datetime, err);
-                    }
+            Some(datetime) => match datetime.parse::<DateTime<Utc>>() {
+                Ok(dt) => route_end = Some(dt.naive_utc()),
+                Err(err) => {
+                    log::error!("cannot parse datetime {}: {}", datetime, err);
                 }
-            }
+            },
         }
         return RouteDateTime {
             start: route_start,
@@ -45,18 +38,14 @@ impl RouteDateTime {
     pub fn match_datetime(&self, datetime: &DateTime<Utc>) -> bool {
         let naive_datetime = datetime.naive_utc();
         match self.start {
-            None => {
-                match self.end {
-                    None => true,
-                    Some(end) => naive_datetime < end,
-                }
+            None => match self.end {
+                None => true,
+                Some(end) => naive_datetime < end,
+            },
+            Some(start) => match self.end {
+                None => naive_datetime >= start,
+                Some(end) => (naive_datetime >= start) && (naive_datetime < end),
             },
-            Some(start) => {
-                match self.end {
-                    None => naive_datetime >= start,
-                    Some(end) => (naive_datetime >= start) && (naive_datetime < end),
-                }
-            }
         }
     }
 }
diff --git a/src/router/route_time.rs b/src/router/route_time.rs
@@ -1,5 +1,5 @@
+use chrono::{DateTime, NaiveTime, Utc};
 use serde::{Deserialize, Serialize};
-use chrono::{NaiveTime, DateTime, Utc};
 
 #[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
 pub struct RouteTime {
@@ -8,33 +8,26 @@ pub struct RouteTime {
 }
 
 impl RouteTime {
-    pub fn from_range(
-        start: &Option<String>,
-        end: &Option<String>,
-    ) -> RouteTime {
+    pub fn from_range(start: &Option<String>, end: &Option<String>) -> RouteTime {
         let mut route_start = None;
         let mut route_end = None;
         match start {
             None => (),
-            Some(time) => {
-                match time.parse::<NaiveTime>() {
-                    Ok(dt) => route_start = Some(dt),
-                    Err(err) => {
-                        log::error!("cannot parse time {}: {}", time, err);
-                    }
+            Some(time) => match time.parse::<NaiveTime>() {
+                Ok(dt) => route_start = Some(dt),
+                Err(err) => {
+                    log::error!("cannot parse time {}: {}", time, err);
                 }
-            }
+            },
         }
         match end {
             None => (),
-            Some(time) => {
-                match time.parse::<NaiveTime>() {
-                    Ok(dt) => route_end = Some(dt),
-                    Err(err) => {
-                        log::error!("cannot parse time {}: {}", time, err);
-                    }
+            Some(time) => match time.parse::<NaiveTime>() {
+                Ok(dt) => route_end = Some(dt),
+                Err(err) => {
+                    log::error!("cannot parse time {}: {}", time, err);
                 }
-            }
+            },
         }
         return RouteTime {
             start: route_start,
@@ -45,18 +38,14 @@ impl RouteTime {
     pub fn match_datetime(&self, datetime: &DateTime<Utc>) -> bool {
         let naive_time = datetime.naive_utc().time();
         match self.start {
-            None => {
-                match self.end {
-                    None => true,
-                    Some(end) => naive_time < end,
-                }
+            None => match self.end {
+                None => true,
+                Some(end) => naive_time < end,
+            },
+            Some(start) => match self.end {
+                None => naive_time >= start,
+                Some(end) => (naive_time >= start) && (naive_time < end),
             },
-            Some(start) => {
-                match self.end {
-                    None => naive_time >= start,
-                    Some(end) => (naive_time >= start) && (naive_time < end),
-                }
-            }
         }
     }
 }
diff --git a/src/router/route_weekday.rs b/src/router/route_weekday.rs
@@ -1,7 +1,7 @@
+use chrono::{DateTime, Datelike, Utc, Weekday};
 use serde::{Deserialize, Serialize};
-use chrono::{Weekday, DateTime, Utc, Datelike};
-use std::fmt::{Display, Formatter, Result};
 use std::cmp::Ordering;
+use std::fmt::{Display, Formatter, Result};
 
 #[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq)]
 pub struct Weekdays(pub Vec<Weekday>);
@@ -12,9 +12,9 @@ pub struct RouteWeekday {
 
 impl Display for Weekdays {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        self.0.iter().fold(Ok(()), |result, weekday| {
-            result.and_then(|_| writeln!(f, "{}", weekday))
-        })
+        self.0
+            .iter()
+            .fold(Ok(()), |result, weekday| result.and_then(|_| writeln!(f, "{}", weekday)))
     }
 }
 
@@ -32,9 +32,7 @@ impl PartialOrd for Weekdays {
 }
 
 impl RouteWeekday {
-    pub fn from_weekdays(
-        weekdays: &Vec<String>,
-    ) -> Option<RouteWeekday> {
+    pub fn from_weekdays(weekdays: &Vec<String>) -> Option<RouteWeekday> {
         let mut route_weekdays = Vec::new();
 
         for weekday in weekdays {
@@ -47,19 +45,19 @@ impl RouteWeekday {
         }
 
         if route_weekdays.is_empty() {
-            return None
+            return None;
         } else {
             return Some(RouteWeekday {
                 weekdays: Weekdays(route_weekdays),
-            })
+            });
         }
     }
 
     pub fn match_datetime(&self, datetime: &DateTime<Utc>) -> bool {
         if (self.weekdays.0).contains(&datetime.weekday()) {
-            return true
+            return true;
         }
-        return false
+        return false;
     }
 }
 
diff --git a/src/router/trace.rs b/src/router/trace.rs
@@ -1,4 +1,4 @@
-use crate::router::request_matcher::{HeaderValueCondition, DateTimeCondition};
+use crate::router::request_matcher::{DateTimeCondition, HeaderValueCondition};
 use crate::router::{Route, RouteData};
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
diff --git a/tests/redirectionio_router_test.rs b/tests/redirectionio_router_test.rs
@@ -7592,7 +7592,7 @@ fn test_rule_date_trigger_multiple_2() {
     let default_config = RouterConfig::default();
     let mut request = Request::new(PathAndQueryWithSkipped::from_config(&default_config, r#"/foo"#), r#"/foo"#.to_string(),None,None,None,None,None);
     
-    request.set_created_at(Some(r#"2023-03-16T00:42:00+00:00"#.to_string()));
+    request.set_created_at(Some(r#"2023-04-16T00:42:00+00:00"#.to_string()));
     
     let request_configured = Request::rebuild_with_config(&router.config, &request);
     let matched = router.match_request(&request_configured);

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use crate::api::{Header, IpConstraint, DateTimeConstraint};`
	`1`	`+use crate::api::{DateTimeConstraint, Header, IpConstraint};`
`2`	`2`	`use serde::{Deserialize, Serialize};`
`3`	`3`
`4`	`4`	`#[derive(Serialize, Deserialize, Debug, Clone)]`
Original file line number	Diff line number	Diff line change
`@@ -232,22 +232,22 @@ impl<T: RouteData> DateTimeMatcher<T> {`
`232`	`232`	`impl DateTimeCondition {`
`233`	`233`	`pub fn match_value(&self, datetime: &DateTime<Utc>) -> bool {`
`234`	`234`	`match self {`
`235`		`- DateTimeCondition::DateTimeRange(route_date_time) => {`
	`235`	`+ DateTimeCondition::DateTimeRange(route_date_time) => {`
`236`	`236`	`for range in route_date_time {`
`237`	`237`	`if range.match_datetime(datetime) {`
`238`	`238`	`return true;`
`239`	`239`	`}`
`240`	`240`	`}`
`241`	`241`	`return false;`
`242`		`- },`
	`242`	`+ }`
`243`	`243`	`DateTimeCondition::TimeRange(route_time) => {`
`244`	`244`	`for range in route_time {`
`245`	`245`	`if range.match_datetime(datetime) {`
`246`	`246`	`return true;`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`	`return false;`
`250`		`- },`
	`250`	`+ }`
`251`	`251`	`DateTimeCondition::Weekdays(route_weekday) => route_weekday.match_datetime(datetime),`
`252`	`252`	`}`
`253`	`253`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
	`1`	`+use chrono::{DateTime, Datelike, Utc, Weekday};`
`1`	`2`	`use serde::{Deserialize, Serialize};`
`2`		`-use chrono::{Weekday, DateTime, Utc, Datelike};`
`3`		`-use std::fmt::{Display, Formatter, Result};`
`4`	`3`	`use std::cmp::Ordering;`
	`4`	`+use std::fmt::{Display, Formatter, Result};`
`5`	`5`
`6`	`6`	`#[derive(Clone, Debug, Hash, Serialize, Deserialize, Eq, PartialEq)]`
`7`	`7`	`pub struct Weekdays(pub Vec<Weekday>);`
`@@ -12,9 +12,9 @@ pub struct RouteWeekday {`
`12`	`12`
`13`	`13`	`impl Display for Weekdays {`
`14`	`14`	`fn fmt(&self, f: &mut Formatter) -> Result {`
`15`		`- self.0.iter().fold(Ok(()), \|result, weekday\| {`
`16`		`- result.and_then(\|_\| writeln!(f, "{}", weekday))`
`17`		`- })`
	`15`	`+ self.0`
	`16`	`+ .iter()`
	`17`	`+ .fold(Ok(()), \|result, weekday\| result.and_then(\|_\| writeln!(f, "{}", weekday)))`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
`@@ -32,9 +32,7 @@ impl PartialOrd for Weekdays {`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`impl RouteWeekday {`
`35`		`- pub fn from_weekdays(`
`36`		`- weekdays: &Vec<String>,`
`37`		`- ) -> Option<RouteWeekday> {`
	`35`	`+ pub fn from_weekdays(weekdays: &Vec<String>) -> Option<RouteWeekday> {`
`38`	`36`	`let mut route_weekdays = Vec::new();`
`39`	`37`
`40`	`38`	`for weekday in weekdays {`
`@@ -47,19 +45,19 @@ impl RouteWeekday {`
`47`	`45`	`}`
`48`	`46`
`49`	`47`	`if route_weekdays.is_empty() {`
`50`		`- return None`
	`48`	`+ return None;`
`51`	`49`	`} else {`
`52`	`50`	`return Some(RouteWeekday {`
`53`	`51`	`weekdays: Weekdays(route_weekdays),`
`54`		`- })`
	`52`	`+ });`
`55`	`53`	`}`
`56`	`54`	`}`
`57`	`55`
`58`	`56`	`pub fn match_datetime(&self, datetime: &DateTime<Utc>) -> bool {`
`59`	`57`	`if (self.weekdays.0).contains(&datetime.weekday()) {`
`60`		`- return true`
	`58`	`+ return true;`
`61`	`59`	`}`
`62`		`- return false`
	`60`	`+ return false;`
`63`	`61`	`}`
`64`	`62`	`}`
`65`	`63`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use crate::router::request_matcher::{HeaderValueCondition, DateTimeCondition};`
	`1`	`+use crate::router::request_matcher::{DateTimeCondition, HeaderValueCondition};`
`2`	`2`	`use crate::router::{Route, RouteData};`
`3`	`3`	`use chrono::{DateTime, Utc};`
`4`	`4`	`use serde::{Deserialize, Serialize};`