Code structure

.gitattributes

@@ -0,0 +1 @@
+*.rs text eol=lf

.github/workflows/ci.yml

@@ -27,6 +27,9 @@ jobs:
       - name: Checkout
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
 
+      - name: Check formatting
+        run: cargo fmt --check
+
       - name: Cargo build 'adblock' package
         run: cargo build --all-features --all-targets
 

benches/bench_cosmetic_matching.rs

@@ -57,13 +57,7 @@ fn by_classes_ids(c: &mut Criterion) {
         let (_, cosmetic_filters) = parse_filters(&rules, false, FilterFormat::Standard);
         let cfcache = CosmeticFilterCache::from_rules(cosmetic_filters);
         let exceptions = Default::default();
-        b.iter(|| {
-            cfcache.hidden_class_id_selectors(
-                &["ad"],
-                &["ad"],
-                &exceptions,
-            )
-        })
+        b.iter(|| cfcache.hidden_class_id_selectors(&["ad"], &["ad"], &exceptions))
     });
     group.bench_function("many lists", move |b| {
         let rules = rules_from_lists(&[
@@ -75,13 +69,7 @@ fn by_classes_ids(c: &mut Criterion) {
         let (_, cosmetic_filters) = parse_filters(&rules, false, FilterFormat::Standard);
         let cfcache = CosmeticFilterCache::from_rules(cosmetic_filters);
         let exceptions = Default::default();
-        b.iter(|| {
-            cfcache.hidden_class_id_selectors(
-                &["ad"],
-                &["ad"],
-                &exceptions,
-            )
-        })
+        b.iter(|| cfcache.hidden_class_id_selectors(&["ad"], &["ad"], &exceptions))
     });
     group.bench_function("many matching classes and ids", move |b| {
         let rules = rules_from_lists(&[

benches/bench_matching.rs

@@ -2,11 +2,11 @@ use criterion::*;
 
 use serde::{Deserialize, Serialize};
 
-use adblock::Engine;
 use adblock::blocker::{Blocker, BlockerOptions};
 use adblock::request::Request;
 use adblock::resources::ResourceStorage;
 use adblock::url_parser::parse_url;
+use adblock::Engine;
 
 #[path = "../tests/test_utils.rs"]
 mod test_utils;
@@ -36,7 +36,7 @@ fn load_requests() -> Vec<TestRequest> {
     reqs
 }
 
-fn get_blocker(rules: impl IntoIterator<Item=impl AsRef<str>>) -> Blocker {
+fn get_blocker(rules: impl IntoIterator<Item = impl AsRef<str>>) -> Blocker {
     let (network_filters, _) = adblock::lists::parse_filters(rules, false, Default::default());
 
     let blocker_options = BlockerOptions {
@@ -61,7 +61,11 @@ fn bench_rule_matching(engine: &Engine, requests: &Vec<TestRequest>) -> (u32, u3
     (matches, passes)
 }
 
-fn bench_matching_only(blocker: &Blocker, resources: &ResourceStorage, requests: &Vec<Request>) -> (u32, u32) {
+fn bench_matching_only(
+    blocker: &Blocker,
+    resources: &ResourceStorage,
+    requests: &Vec<Request>,
+) -> (u32, u32) {
     let mut matches = 0;
     let mut passes = 0;
     requests.iter().for_each(|parsed| {
@@ -78,10 +82,7 @@ fn bench_matching_only(blocker: &Blocker, resources: &ResourceStorage, requests:
 
 type ParsedRequest = (String, String, String, String, bool);
 
-fn bench_rule_matching_browserlike(
-    blocker: &Engine,
-    requests: &Vec<ParsedRequest>,
-) -> (u32, u32) {
+fn bench_rule_matching_browserlike(blocker: &Engine, requests: &Vec<ParsedRequest>) -> (u32, u32) {
     let mut matches = 0;
     let mut passes = 0;
     requests.iter().for_each(
@@ -141,9 +142,7 @@ fn rule_match(c: &mut Criterion) {
 fn rule_match_parsed_el(c: &mut Criterion) {
     let mut group = c.benchmark_group("rule-match-parsed");
 
-    let rules = rules_from_lists(&[
-        "data/easylist.to/easylist/easylist.txt",
-    ]);
+    let rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
     let requests = load_requests();
     let requests_parsed: Vec<_> = requests
         .into_iter()
@@ -221,9 +220,7 @@ fn serialization(c: &mut Criterion) {
         b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
     });
     group.bench_function("el", move |b| {
-        let full_rules = rules_from_lists(&[
-            "data/easylist.to/easylist/easylist.txt",
-        ]);
+        let full_rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
 
         let engine = Engine::from_rules(full_rules, Default::default());
         b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
@@ -258,9 +255,7 @@ fn deserialization(c: &mut Criterion) {
         })
     });
     group.bench_function("el", move |b| {
-        let full_rules = rules_from_lists(&[
-            "data/easylist.to/easylist/easylist.txt",
-        ]);
+        let full_rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
 
         let engine = Engine::from_rules(full_rules, Default::default());
         let serialized = engine.serialize_raw().unwrap();
@@ -294,9 +289,7 @@ fn rule_match_browserlike_comparable(c: &mut Criterion) {
     group.throughput(Throughput::Elements(requests_len));
     group.sample_size(20);
 
-    fn requests_parsed(
-        requests: &[TestRequest],
-    ) -> Vec<(String, String, String, String, bool)> {
+    fn requests_parsed(requests: &[TestRequest]) -> Vec<(String, String, String, String, bool)> {
         requests
             .iter()
             .map(|r| {
@@ -354,10 +347,10 @@ fn rule_match_browserlike_comparable(c: &mut Criterion) {
         b.iter(|| bench_rule_matching_browserlike(&engine, &requests))
     });
     group.bench_function("brave-list", |b| {
-      let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
-      let engine = Engine::from_rules_parametrised(rules, Default::default(), false, true);
-      b.iter(|| bench_rule_matching_browserlike(&engine, &requests))
-  });
+        let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
+        let engine = Engine::from_rules_parametrised(rules, Default::default(), false, true);
+        b.iter(|| bench_rule_matching_browserlike(&engine, &requests))
+    });
 
     group.finish();
 }
@@ -376,21 +369,20 @@ fn rule_match_first_request(c: &mut Criterion) {
     )];
 
     group.bench_function("brave-list", |b| {
-        b.iter_custom(
-            |iters| {
-                let mut total_time = std::time::Duration::ZERO;
-                for _ in 0..iters {
-                  let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
-                  let engine = Engine::from_rules_parametrised(rules, Default::default(), false, true);
-
-                  // Measure only the matching time, skip setup and destruction
-                  let start_time = std::time::Instant::now();
-                  bench_rule_matching_browserlike(&engine, &requests);
-                  total_time += start_time.elapsed();
-                }
-                total_time
+        b.iter_custom(|iters| {
+            let mut total_time = std::time::Duration::ZERO;
+            for _ in 0..iters {
+                let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
+                let engine =
+                    Engine::from_rules_parametrised(rules, Default::default(), false, true);
+
+                // Measure only the matching time, skip setup and destruction
+                let start_time = std::time::Instant::now();
+                bench_rule_matching_browserlike(&engine, &requests);
+                total_time += start_time.elapsed();
             }
-        )
+            total_time
+        })
     });
 
     group.finish();

benches/bench_memory.rs

@@ -4,12 +4,12 @@
  * You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use criterion::*;
+use serde::{Deserialize, Serialize};
 use std::alloc::{GlobalAlloc, Layout, System};
 use std::sync::atomic::{AtomicUsize, Ordering};
-use serde::{Deserialize, Serialize};
 
-use adblock::Engine;
 use adblock::request::Request;
+use adblock::Engine;
 
 #[path = "../tests/test_utils.rs"]
 mod test_utils;
@@ -110,15 +110,15 @@ fn bench_memory_usage(c: &mut Criterion) {
         let mut result = 0;
         b.iter_custom(|iters| {
             for _ in 0..iters {
-              ALLOCATOR.reset();
-              let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
-              let engine = Engine::from_rules(rules, Default::default());
+                ALLOCATOR.reset();
+                let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
+                let engine = Engine::from_rules(rules, Default::default());
 
-              noise += 1; // add some noise to make criterion happy
-              result += ALLOCATOR.current_usage() + noise;
+                noise += 1; // add some noise to make criterion happy
+                result += ALLOCATOR.current_usage() + noise;
 
-              // Prevent engine from being optimized
-              criterion::black_box(&engine);
+                // Prevent engine from being optimized
+                criterion::black_box(&engine);
             }
 
             // Return the memory usage as a Duration
@@ -134,15 +134,15 @@ fn bench_memory_usage(c: &mut Criterion) {
                 let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
                 let engine = Engine::from_rules(rules, Default::default());
 
-              for request in first_1000_requests.clone() {
-                  criterion::black_box(engine.check_network_request(&request.into()));
-              }
+                for request in first_1000_requests.clone() {
+                    criterion::black_box(engine.check_network_request(&request.into()));
+                }
 
-              noise += 1; // add some noise to make criterion happy
-              result += ALLOCATOR.current_usage() + noise;
+                noise += 1; // add some noise to make criterion happy
+                result += ALLOCATOR.current_usage() + noise;
 
-              // Prevent engine from being optimized
-              criterion::black_box(&engine);
+                // Prevent engine from being optimized
+                criterion::black_box(&engine);
             }
 
             // Return the memory usage as a Duration

benches/bench_redirect_performance.rs

@@ -66,9 +66,7 @@ fn get_redirect_rules() -> Vec<NetworkFilter> {
         .into_iter()
         .filter(NetworkFilter::is_redirect)
         .filter(NetworkFilter::also_block_redirect)
-        .filter(|rule| {
-            rule.modifier_option.as_ref().unwrap() != "none"
-        })
+        .filter(|rule| rule.modifier_option.as_ref().unwrap() != "none")
         .enumerate()
         .map(|(index, mut rule)| {
             rule.mask.insert(NetworkFilterMask::IS_LEFT_ANCHOR);
@@ -102,8 +100,8 @@ fn build_resources_for_filters(#[allow(unused)] filters: &[NetworkFilter]) -> Re
 
     #[cfg(feature = "resource-assembler")]
     {
-        use std::path::Path;
         use adblock::resources::resource_assembler::assemble_web_accessible_resources;
+        use std::path::Path;
 
         let mut resource_data = assemble_web_accessible_resources(
             Path::new("data/test/fake-uBO-files/web_accessible_resources"),
@@ -116,16 +114,14 @@ fn build_resources_for_filters(#[allow(unused)] filters: &[NetworkFilter]) -> Re
             )),
         );
 
-        resource_data
-            .into_iter()
-            .for_each(|resource| {
-                let _res = resources.add_resource(resource);
-            });
+        resource_data.into_iter().for_each(|resource| {
+            let _res = resources.add_resource(resource);
+        });
     }
 
     #[cfg(not(feature = "resource-assembler"))]
     {
-        use adblock::resources::{Resource, ResourceType, MimeType};
+        use adblock::resources::{MimeType, Resource, ResourceType};
 
         filters
             .iter()
@@ -213,19 +209,20 @@ pub fn build_custom_requests(rules: Vec<NetworkFilter>) -> Vec<Request> {
 
             let source_url = format!("https://{}", source_hostname);
 
-            Request::new(
-                &url,
-                &source_url,
-                raw_type,
-            ).unwrap()
+            Request::new(&url, &source_url, raw_type).unwrap()
         })
         .collect::<Vec<_>>()
 }
 
 fn bench_fn(blocker: &Blocker, resources: &ResourceStorage, requests: &[Request]) {
     requests.iter().for_each(|request| {
         let block_result = blocker.check(&request, &resources);
-        assert!(block_result.redirect.is_some(), "{:?}, {:?}", request, block_result);
+        assert!(
+            block_result.redirect.is_some(),
+            "{:?}, {:?}",
+            request,
+            block_result
+        );
     });
 }
 

benches/bench_rules.rs

@@ -7,11 +7,8 @@ use adblock::blocker::{Blocker, BlockerOptions};
 mod test_utils;
 use test_utils::rules_from_lists;
 
-static DEFAULT_LISTS: Lazy<Vec<String>> = Lazy::new(|| {
-    rules_from_lists(&[
-        "data/easylist.to/easylist/easylist.txt",
-    ]).collect()
-});
+static DEFAULT_LISTS: Lazy<Vec<String>> =
+    Lazy::new(|| rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]).collect());
 
 fn bench_string_hashing(filters: &Vec<String>) -> adblock::utils::Hash {
     let mut dummy: adblock::utils::Hash = 0;
@@ -81,7 +78,7 @@ fn list_parse(c: &mut Criterion) {
     group.finish();
 }
 
-fn get_blocker(rules: impl IntoIterator<Item=impl AsRef<str>>) -> Blocker {
+fn get_blocker(rules: impl IntoIterator<Item = impl AsRef<str>>) -> Blocker {
     let (network_filters, _) = adblock::lists::parse_filters(rules, false, Default::default());
 
     let blocker_options = BlockerOptions {
@@ -100,13 +97,14 @@ fn blocker_new(c: &mut Criterion) {
     let easylist_rules: Vec<_> = rules_from_lists(&[
         "data/easylist.to/easylist/easylist.txt",
         "data/easylist.to/easylist/easyprivacy.txt",
-    ]).collect();
-    let brave_list_rules: Vec<_> = rules_from_lists(&[
-        "data/brave/brave-main-list.txt",
-    ]).collect();
+    ])
+    .collect();
+    let brave_list_rules: Vec<_> = rules_from_lists(&["data/brave/brave-main-list.txt"]).collect();
 
     group.bench_function("el+ep", move |b| b.iter(|| get_blocker(&easylist_rules)));
-    group.bench_function("brave-list", move |b| b.iter(|| get_blocker(&brave_list_rules)));
+    group.bench_function("brave-list", move |b| {
+        b.iter(|| get_blocker(&brave_list_rules))
+    });
 
     group.finish();
 }

examples/deserialization.rs

@@ -1,7 +1,4 @@
-use adblock::{
-    Engine,
-    request::Request,
-};
+use adblock::{request::Request, Engine};
 
 use serde::Deserialize;
 

examples/example.rs

@@ -1,7 +1,7 @@
 use adblock::{
-    Engine,
     lists::{FilterSet, ParseOptions},
     request::Request,
+    Engine,
 };
 
 fn main() {
@@ -22,7 +22,8 @@ fn main() {
         "http://example.com/-advertisement-icon.",
         "http://example.com/helloworld",
         "image",
-    ).unwrap();
+    )
+    .unwrap();
     let blocker_result = engine.check_network_request(&request);
 
     println!("Blocker result: {:?}", blocker_result);