Flat buffers

Cargo.toml

@@ -41,6 +41,7 @@ cssparser = { version = "0.28", optional = true }
 selectors = { version = "0.23", optional = true }
 serde_json = "1.0"
 thiserror = "1.0"
+flatbuffers = "24.12.23"
 
 [dev-dependencies]
 criterion = "0.5"
@@ -55,6 +56,9 @@ sha2 = "0.9"
 [lib]
 bench = false
 
+[profile.bench]
+debug = true
+
 [[bench]]
 name = "bench_regex"
 harness = false
@@ -98,3 +102,4 @@ css-validation = ["cssparser", "selectors"]
 content-blocking = []
 embedded-domain-resolver = ["addr"] # Requires setting an external domain resolver if disabled.
 resource-assembler = []
+flatbuffers = []

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| {
@@ -141,9 +145,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 +223,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 +258,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 +292,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| {

benches/bench_redirect_performance.rs

@@ -2,6 +2,7 @@ use criterion::*;
 use tokio::runtime::Runtime;
 
 use adblock::blocker::{Blocker, BlockerOptions};
+use adblock::filters::network::NetworkFilterMaskHelper;
 use adblock::filters::network::{NetworkFilter, NetworkFilterMask};
 use adblock::request::Request;
 use adblock::resources::ResourceStorage;
@@ -66,9 +67,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 +101,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 +115,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 +210,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,10 +97,12 @@ 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();
+    ])
+    .collect();
     let brave_list_rules: Vec<_> = rules_from_lists(&[
         "data/brave/brave-main-list.txt",
-    ]).collect();
+    ])
+    .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)));

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);

examples/generate-dat.rs

@@ -1,7 +1,4 @@
-use adblock::{
-    Engine,
-    request::Request,
-};
+use adblock::{request::Request, Engine};
 
 use std::fs::File;
 use std::io::prelude::*;
@@ -20,12 +17,10 @@ fn main() {
     let request = Request::new(
         "https://platform.twitter.com/widgets.js",
         "https://fmarier.github.io/brave-testing/social-widgets.html",
-        "script"
-    ).unwrap();
-    assert!(engine
-        .check_network_request(&request)
-        .exception
-        .is_some());
+        "script",
+    )
+    .unwrap();
+    assert!(engine.check_network_request(&request).exception.is_some());
     let serialized = engine.serialize_raw().expect("Could not serialize!");
 
     // Write to file

examples/use-dat.rs

@@ -1,7 +1,4 @@
-use adblock::{
-    Engine,
-    request::Request,
-};
+use adblock::{request::Request, Engine};
 
 use std::fs::File;
 use std::io::prelude::*;
@@ -23,7 +20,8 @@ fn main() {
         "https://platform.twitter.com/widgets.js",
         "https://fmarier.github.io/brave-testing/social-widgets.html",
         "script",
-    ).unwrap();
+    )
+    .unwrap();
     let checked = engine.check_network_request(&request);
     assert!(checked.filter.is_some());
     assert!(checked.exception.is_some());