@lovrozagar/honey 0.6.8 → 0.7.0

package/src/client-rust/invalidation_sync.rs

@@ -7,24 +7,16 @@
    without requiring an async runtime. Reuses the shared StaleEntry /
    RequestMeta types + pattern/interpolation helpers from invalidation.rs. */
 
-use crate::invalidation::{
-    path_matches_pattern, resolve_invalidation_targets_for_mutation, RequestMeta, StaleEntry,
-};
+use crate::invalidation::{resolve_invalidation_targets_for_mutation, tracker_settings, RequestMeta, TrackerState};
 use crate::runtime::InvalidationConfig;
 use std::collections::HashMap;
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
-struct TrackerStateSync {
-    entries: HashMap<String, StaleEntry>,
-    order: Vec<String>,
-    seq: u64,
-}
-
 /// StaleTrackerSync is the blocking counterpart of StaleTracker.
 /// All public methods are safe for concurrent blocking use (interior std Mutex).
 pub struct StaleTrackerSync {
-    state: Mutex<TrackerStateSync>,
+    state: Mutex<TrackerState>,
     enabled: bool,
     stale_time: Duration,
     max_entries: usize,
@@ -35,33 +27,8 @@ impl StaleTrackerSync {
     /// new constructs a tracker from an InvalidationConfig.
     /// Tracker is disabled (cheap no-op) when cfg is None or stale_time ≤ 0.
     pub fn new(cfg: Option<&InvalidationConfig>) -> Self {
-        let mut enabled = false;
-        let mut stale_time = Duration::from_millis(0);
-        let mut max_entries = 1000usize;
-        let mut max_sources = 16usize;
-        if let Some(c) = cfg {
-            if c.stale_time > 0 {
-                enabled = true;
-                stale_time = Duration::from_millis(c.stale_time as u64);
-                if c.stale_max_entries > 0 {
-                    max_entries = c.stale_max_entries;
-                }
-                if c.max_sources_per_target > 0 {
-                    max_sources = c.max_sources_per_target;
-                }
-            }
-        }
-        StaleTrackerSync {
-            state: Mutex::new(TrackerStateSync {
-                entries: HashMap::new(),
-                order: Vec::new(),
-                seq: 0,
-            }),
-            enabled,
-            stale_time,
-            max_entries,
-            max_sources,
-        }
+        let (enabled, stale_time, max_entries, max_sources) = tracker_settings(cfg);
+        StaleTrackerSync { state: Mutex::new(TrackerState::default()), enabled, stale_time, max_entries, max_sources }
     }
 
     /// enabled reports whether the tracker will record / report stale entries.
@@ -71,12 +38,7 @@ impl StaleTrackerSync {
 
     /// mark_stale bumps seq, expands templated invalidation entries with
     /// `params`, and records each resolved target as freshly stale.
-    pub fn mark_stale(
-        &self,
-        invalidate: &[String],
-        params: &HashMap<String, String>,
-        mutation_selector: &str,
-    ) {
+    pub fn mark_stale(&self, invalidate: &[String], params: &HashMap<String, String>, mutation_selector: &str) {
         if !self.enabled || invalidate.is_empty() {
             return;
         }
@@ -84,69 +46,28 @@ impl StaleTrackerSync {
         s.seq += 1;
         let seq = s.seq;
         let until = Instant::now() + self.stale_time;
-        let resolved = resolve_invalidation_targets_for_mutation(invalidate, params);
-        for target in resolved {
-            upsert_locked(&mut s, &target, until, seq, mutation_selector, self.max_sources);
+        for target in resolve_invalidation_targets_for_mutation(invalidate, params) {
+            s.upsert(&target, until, seq, mutation_selector, self.max_sources);
         }
-        enforce_capacity_locked(&mut s, self.max_entries);
+        s.enforce_capacity(self.max_entries);
     }
 
     /// lookup_stale returns (invalidated_by, is_stale): exact + pattern lookup
     /// with expired-key sweep. Disabled tracker → (vec![], false).
-    pub fn lookup_stale(
-        &self,
-        concrete_selector: &str,
-        concrete_path: &str,
-        method: &str,
-        now: Instant,
-    ) -> (Vec<String>, bool) {
+    pub fn lookup_stale(&self, concrete_selector: &str, concrete_path: &str, method: &str, now: Instant) -> (Vec<String>, bool) {
         if !self.enabled {
             return (Vec::new(), false);
         }
-        let mut s = self.state.lock().unwrap();
-        lookup_locked(&mut s, concrete_selector, concrete_path, method, now)
+        self.state.lock().unwrap().lookup(concrete_selector, concrete_path, method, now)
     }
 
     /// clear_stale drops stale entries whose seq ≤ seq_snapshot and which match
     /// the given concrete_path under method (exact key + pattern keys).
-    pub fn clear_stale(
-        &self,
-        concrete_selector: &str,
-        concrete_path: &str,
-        method: &str,
-        seq_snapshot: u64,
-    ) {
+    pub fn clear_stale(&self, concrete_selector: &str, concrete_path: &str, method: &str, seq_snapshot: u64) {
         if !self.enabled {
             return;
         }
-        let mut s = self.state.lock().unwrap();
-        if let Some(entry) = s.entries.get(concrete_selector) {
-            if entry.seq <= seq_snapshot {
-                delete_locked(&mut s, concrete_selector);
-            }
-        }
-        let mut to_delete: Vec<String> = Vec::new();
-        for (key, entry) in s.entries.iter() {
-            if entry.seq > seq_snapshot {
-                continue;
-            }
-            if !key.contains('{') && !key.contains(':') {
-                continue;
-            }
-            let space_idx = match key.find(' ') {
-                Some(i) => i,
-                None => continue,
-            };
-            if &key[..space_idx] != method {
-                continue;
-            }
-            if path_matches_pattern(concrete_path, &key[space_idx + 1..]) {
-                to_delete.push(key.clone());
-            }
-        }
-        for key in to_delete {
-            delete_locked(&mut s, &key);
-        }
+        self.state.lock().unwrap().clear(concrete_selector, concrete_path, method, seq_snapshot);
     }
 
     /// is_stale reports whether (method, path) currently sits inside an active
@@ -155,152 +76,18 @@ impl StaleTrackerSync {
         if !self.enabled {
             return false;
         }
-        let mut s = self.state.lock().unwrap();
         let selector = format!("{} {}", method, path);
-        let (_, is_stale) = lookup_locked(&mut s, &selector, path, method, Instant::now());
-        is_stale
+        self.state.lock().unwrap().lookup(&selector, path, method, Instant::now()).1
     }
 
     /// build_request_meta returns a RequestMeta snapshot for the request about
     /// to fire, or None when tracker is disabled.
-    pub fn build_request_meta(
-        &self,
-        concrete_selector: &str,
-        concrete_path: &str,
-        method: &str,
-    ) -> Option<RequestMeta> {
+    pub fn build_request_meta(&self, concrete_selector: &str, concrete_path: &str, method: &str) -> Option<RequestMeta> {
         if !self.enabled {
             return None;
         }
         let mut s = self.state.lock().unwrap();
-        let (by, is_stale) =
-            lookup_locked(&mut s, concrete_selector, concrete_path, method, Instant::now());
-        Some(RequestMeta {
-            selector: concrete_selector.to_string(),
-            is_stale,
-            invalidated_by: by,
-            seq_snapshot: s.seq,
-        })
-    }
-}
-
-fn upsert_locked(
-    s: &mut TrackerStateSync,
-    key: &str,
-    until: Instant,
-    seq: u64,
-    mutation_selector: &str,
-    max_sources: usize,
-) {
-    if let Some(existing) = s.entries.get_mut(key) {
-        existing.until = until;
-        existing.seq = seq;
-        if !mutation_selector.is_empty() && existing.by.len() < max_sources {
-            let already = existing.by.iter().any(|b| b == mutation_selector);
-            if !already {
-                existing.by.push(mutation_selector.to_string());
-            }
-        }
-        touch_order_locked(s, key);
-        return;
-    }
-    let by = if mutation_selector.is_empty() {
-        Vec::new()
-    } else {
-        vec![mutation_selector.to_string()]
-    };
-    s.entries.insert(key.to_string(), StaleEntry { by, seq, until });
-    s.order.push(key.to_string());
-}
-
-fn touch_order_locked(s: &mut TrackerStateSync, key: &str) {
-    if let Some(idx) = s.order.iter().position(|k| k == key) {
-        s.order.remove(idx);
-    }
-    s.order.push(key.to_string());
-}
-
-fn delete_locked(s: &mut TrackerStateSync, key: &str) {
-    if s.entries.remove(key).is_none() {
-        return;
-    }
-    if let Some(idx) = s.order.iter().position(|k| k == key) {
-        s.order.remove(idx);
-    }
-}
-
-fn lookup_locked(
-    s: &mut TrackerStateSync,
-    concrete_selector: &str,
-    concrete_path: &str,
-    method: &str,
-    now: Instant,
-) -> (Vec<String>, bool) {
-    let mut all_by: Vec<String> = Vec::new();
-    let mut exact_expired = false;
-    if let Some(exact) = s.entries.get(concrete_selector) {
-        if exact.until > now {
-            all_by.extend(exact.by.iter().cloned());
-        } else {
-            exact_expired = true;
-        }
-    }
-    if exact_expired {
-        delete_locked(s, concrete_selector);
-    }
-    let mut expired: Vec<String> = Vec::new();
-    for (key, entry) in s.entries.iter() {
-        if entry.until <= now {
-            expired.push(key.clone());
-            continue;
-        }
-        if key == concrete_selector {
-            continue;
-        }
-        if !key.contains('{') && !key.contains(':') {
-            continue;
-        }
-        let space_idx = match key.find(' ') {
-            Some(i) => i,
-            None => continue,
-        };
-        if &key[..space_idx] != method {
-            continue;
-        }
-        if path_matches_pattern(concrete_path, &key[space_idx + 1..]) {
-            all_by.extend(entry.by.iter().cloned());
-        }
-    }
-    for key in expired {
-        delete_locked(s, &key);
-    }
-    let mut deduped: Vec<String> = Vec::with_capacity(all_by.len());
-    for src in all_by {
-        if !deduped.iter().any(|d| d == &src) {
-            deduped.push(src);
-        }
-    }
-    let any = !deduped.is_empty();
-    (deduped, any)
-}
-
-fn enforce_capacity_locked(s: &mut TrackerStateSync, max_entries: usize) {
-    if s.entries.len() <= max_entries {
-        return;
-    }
-    let now = Instant::now();
-    let expired: Vec<String> = s
-        .entries
-        .iter()
-        .filter(|(_, e)| e.until <= now)
-        .map(|(k, _)| k.clone())
-        .collect();
-    for key in expired {
-        delete_locked(s, &key);
-    }
-    let target = if max_entries / 2 < 1 { 1 } else { max_entries / 2 };
-    while s.entries.len() > target && !s.order.is_empty() {
-        let oldest = s.order[0].clone();
-        delete_locked(s, &oldest);
+        let (by, is_stale) = s.lookup(concrete_selector, concrete_path, method, Instant::now());
+        Some(RequestMeta { selector: concrete_selector.to_string(), is_stale, invalidated_by: by, seq_snapshot: s.seq })
     }
 }

package/src/client-rust/nullable.rs

@@ -0,0 +1,17 @@
+/* Code generated by honey. DO NOT EDIT. */
+
+//! Optional fields that may also be null.
+//!
+//! Such a field is `Option<Option<T>>`: `None` leaves the key out, `Some(None)` sends an explicit
+//! `null`, `Some(Some(v))` a value. `#[serde(default)]` keeps a missing key `None`;
+//! `deserialize` turns a present `null` into `Some(None)` (serde alone would read it as `None`).
+
+use serde::{Deserialize, Deserializer};
+
+pub fn deserialize<'de, D, T>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de>,
+{
+    Option::<T>::deserialize(deserializer).map(Some)
+}