Fix clippy inlined_format_args (#533)

Author: atuchin-m

Cargo.toml

@@ -105,8 +105,7 @@ resource-assembler = []
 
 [lints.clippy]
 len_zero = "allow"
-# TODO: https://github.com/brave/adblock-rust/issues/501
-uninlined_format_args = "allow"
+uninlined_format_args = "warn"
 
 [workspace]
 members = ["js", "fuzz"]

benches/bench_cosmetic_matching.rs

@@ -51,8 +51,8 @@ fn by_classes_ids(c: &mut Criterion) {
 
     group.bench_function("brave-list", |b| {
         for i in 0..1000 {
-            classes.push(format!("class{}", i));
-            ids.push(format!("id{}", i));
+            classes.push(format!("class{i}"));
+            ids.push(format!("id{i}"));
         }
 
         let engine = make_engine();

benches/bench_redirect_performance.rs

@@ -71,7 +71,7 @@ fn get_redirect_rules() -> Vec<NetworkFilter> {
         .map(|(index, mut rule)| {
             rule.mask.insert(NetworkFilterMask::IS_LEFT_ANCHOR);
             rule.mask.insert(NetworkFilterMask::IS_RIGHT_ANCHOR);
-            rule.hostname = Some(format!("a{}.com/bad.js", index));
+            rule.hostname = Some(format!("a{index}.com/bad.js"));
 
             rule.filter = adblock::filters::network::FilterPart::Empty;
             rule.mask.remove(NetworkFilterMask::IS_HOSTNAME_ANCHOR);
@@ -192,7 +192,7 @@ pub fn build_custom_requests(rules: Vec<NetworkFilter>) -> Vec<Request> {
                 hostname
             };
 
-            let source_url = format!("https://{}", source_hostname);
+            let source_url = format!("https://{source_hostname}");
 
             Request::new(&url, &source_url, raw_type).unwrap()
         })
@@ -204,9 +204,7 @@ fn bench_fn(engine: &Engine, requests: &[Request]) {
         let block_result = engine.check_network_request(request);
         assert!(
             block_result.redirect.is_some(),
-            "{:?}, {:?}",
-            request,
-            block_result
+            "{request:?}, {block_result:?}"
         );
     });
 }

examples/deserialization.rs

@@ -29,7 +29,7 @@ fn load_requests() -> Vec<RequestRuleMatch> {
         if let Ok(record) = result {
             reqs.push(record);
         } else {
-            println!("Could not parse {:?}", result);
+            println!("Could not parse {result:?}");
         }
     }
 
@@ -70,7 +70,7 @@ fn main() {
     let mut false_negative_exceptions: HashMap<String, (String, String, String)> = HashMap::new();
     for (reqs_processed, req) in requests.into_iter().enumerate() {
         if reqs_processed % 10000 == 0 {
-            println!("{} requests processed", reqs_processed);
+            println!("{reqs_processed} requests processed");
         }
         let request = Request::new(&req.url, &req.sourceUrl, &req.r#type).unwrap();
         let checked = engine.check_network_request(&request);
@@ -106,7 +106,7 @@ fn main() {
 
     let mismatches = mismatch_expected_match + mismatch_expected_exception + mismatch_expected_pass;
     let ratio = mismatches as f32 / requests_len as f32;
-    assert!(ratio < 0.04, "Mismatch ratio was {}", ratio);
+    assert!(ratio < 0.04, "Mismatch ratio was {ratio}");
     assert!(
         false_positive_rules.len() < 3,
         "False positive rules higher than expected: {:?}",

examples/example.rs

@@ -26,5 +26,5 @@ fn main() {
     .unwrap();
     let blocker_result = engine.check_network_request(&request);
 
-    println!("Blocker result: {:?}", blocker_result);
+    println!("Blocker result: {blocker_result:?}");
 }

examples/use-dat.rs

@@ -25,5 +25,5 @@ fn main() {
     let checked = engine.check_network_request(&request);
     assert!(checked.filter.is_some());
     assert!(checked.exception.is_some());
-    println!("All good: {:?}", checked);
+    println!("All good: {checked:?}");
 }

src/blocker.rs

@@ -299,8 +299,8 @@ impl Blocker {
         impl std::fmt::Display for QParam<'_> {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 match self {
-                    Self::KeyOnly(k) => write!(f, "{}", k),
-                    Self::KeyValue(k, v) => write!(f, "{}={}", k, v),
+                    Self::KeyOnly(k) => write!(f, "{k}"),
+                    Self::KeyValue(k, v) => write!(f, "{k}={v}"),
                 }
             }
         }
@@ -354,7 +354,7 @@ impl Blocker {
                 let new_param_str = if p.is_empty() {
                     String::from("")
                 } else {
-                    format!("?{}", p)
+                    format!("?{p}")
                 };
                 Some(format!(
                     "{}{}{}",

src/content_blocking.rs

@@ -377,7 +377,7 @@ impl TryFrom<NetworkFilter> for CbRuleEquivalent {
                     let with_fixed_wildcards =
                         REPLACE_WILDCARDS.replace_all(&escaped_special_chars, ".*");
                     let mut url_filter = if v.mask.contains(NetworkFilterMask::IS_LEFT_ANCHOR) {
-                        format!("^{}", with_fixed_wildcards)
+                        format!("^{with_fixed_wildcards}")
                     } else {
                         let scheme_part = if v
                             .mask
@@ -394,7 +394,7 @@ impl TryFrom<NetworkFilter> for CbRuleEquivalent {
                             unreachable!("Invalid scheme information");
                         };
 
-                        format!("{}{}", scheme_part, with_fixed_wildcards)
+                        format!("{scheme_part}{with_fixed_wildcards}")
                     };
 
                     if v.mask.contains(NetworkFilterMask::IS_RIGHT_ANCHOR) {
@@ -405,7 +405,7 @@ impl TryFrom<NetworkFilter> for CbRuleEquivalent {
                 }
                 (crate::filters::network::FilterPart::Empty, Some(hostname)) => {
                     let escaped_special_chars = SPECIAL_CHARS.replace_all(&hostname, r##"\$1"##);
-                    format!("^[^:]+:(//)?([^/]+\\.)?{}", escaped_special_chars)
+                    format!("^[^:]+:(//)?([^/]+\\.)?{escaped_special_chars}")
                 }
                 (crate::filters::network::FilterPart::Empty, None) => if v
                     .mask
@@ -464,7 +464,7 @@ impl TryFrom<NetworkFilter> for CbRuleEquivalent {
                         idna::domain_to_ascii(&lowercase).unwrap()
                     };
 
-                    collection.push(format!("*{}", normalized_domain));
+                    collection.push(format!("*{normalized_domain}"));
                 });
 
                 (non_empty(if_domain), non_empty(unless_domain))

src/cosmetic_filter_cache.rs

@@ -183,8 +183,8 @@ impl CosmeticFilterCache {
 
         classes.into_iter().for_each(|class| {
             let class = class.as_ref();
-            if simple_class_rules.contains(class) && !exceptions.contains(&format!(".{}", class)) {
-                selectors.push(format!(".{}", class));
+            if simple_class_rules.contains(class) && !exceptions.contains(&format!(".{class}")) {
+                selectors.push(format!(".{class}"));
             }
             if let Some(values) = complex_class_rules.get(class) {
                 for sel in values.data() {
@@ -196,8 +196,8 @@ impl CosmeticFilterCache {
         });
         ids.into_iter().for_each(|id| {
             let id = id.as_ref();
-            if simple_id_rules.contains(id) && !exceptions.contains(&format!("#{}", id)) {
-                selectors.push(format!("#{}", id));
+            if simple_id_rules.contains(id) && !exceptions.contains(&format!("#{id}")) {
+                selectors.push(format!("#{id}"));
             }
             if let Some(values) = complex_id_rules.get(id) {
                 for sel in values.data() {

src/filters/cosmetic.rs

@@ -634,7 +634,7 @@ mod css_validation {
 
         // Use `mock-stylesheet-marker` where uBO uses `color: red` since we have control over the
         // parsing logic within the block.
-        let mock_stylesheet = format!("{}{{mock-stylesheet-marker}}", selector);
+        let mock_stylesheet = format!("{selector}{{mock-stylesheet-marker}}");
         let mut pi = ParserInput::new(&mock_stylesheet);
         let mut parser = Parser::new(&mut pi);
         let mut parser_impl = QualifiedRuleParserImpl {
@@ -1137,17 +1137,17 @@ mod css_validation {
         fn to_css<W: Write>(&self, dest: &mut W) -> FmtResult {
             write!(dest, ":")?;
             match self {
-                Self::HasText(text) => write!(dest, "has-text({})", text)?,
-                Self::MatchesAttr(text) => write!(dest, "matches-attr({})", text)?,
-                Self::MatchesCss(text) => write!(dest, "matches-css({})", text)?,
-                Self::MatchesCssBefore(text) => write!(dest, "matches-css-before({})", text)?,
-                Self::MatchesCssAfter(text) => write!(dest, "matches-css-after({})", text)?,
-                Self::MatchesPath(text) => write!(dest, "matches-path({})", text)?,
-                Self::MinTextLength(text) => write!(dest, "min-text-length({})", text)?,
-                Self::Upward(text) => write!(dest, "upward({})", text)?,
-                Self::Xpath(text) => write!(dest, "xpath({})", text)?,
-                Self::AnythingElse(name, None) => write!(dest, "{}", name)?,
-                Self::AnythingElse(name, Some(args)) => write!(dest, "{}({})", name, args)?,
+                Self::HasText(text) => write!(dest, "has-text({text})")?,
+                Self::MatchesAttr(text) => write!(dest, "matches-attr({text})")?,
+                Self::MatchesCss(text) => write!(dest, "matches-css({text})")?,
+                Self::MatchesCssBefore(text) => write!(dest, "matches-css-before({text})")?,
+                Self::MatchesCssAfter(text) => write!(dest, "matches-css-after({text})")?,
+                Self::MatchesPath(text) => write!(dest, "matches-path({text})")?,
+                Self::MinTextLength(text) => write!(dest, "min-text-length({text})")?,
+                Self::Upward(text) => write!(dest, "upward({text})")?,
+                Self::Xpath(text) => write!(dest, "xpath({text})")?,
+                Self::AnythingElse(name, None) => write!(dest, "{name}")?,
+                Self::AnythingElse(name, Some(args)) => write!(dest, "{name}({args})")?,
             }
             Ok(())
         }
@@ -1198,8 +1198,8 @@ mod css_validation {
         fn to_css<W: Write>(&self, dest: &mut W) -> FmtResult {
             write!(dest, "::")?;
             match self {
-                Self(name, None) => write!(dest, "{}", name)?,
-                Self(name, Some(args)) => write!(dest, "{}({})", name, args)?,
+                Self(name, None) => write!(dest, "{name}")?,
+                Self(name, Some(args)) => write!(dest, "{name}({args})")?,
             }
             Ok(())
         }