deny.toml

@@ -10,6 +10,7 @@ allow = [
     "BSD-2-Clause",
     "MIT",
     "Unicode-DFS-2016",
+    "Zlib",
 ]
 confidence-threshold = 0.8
 

governor/CHANGELOG.md

@@ -4,6 +4,19 @@
 
 ## [Unreleased] - ReleaseDate
 
+## [[0.9.0](https://docs.rs/governor/0.9.0/governor/)] - 2025-03-24
+
+## Changed
+
+- Governor no longer uses the
+  [`no_std_compat` crate](https://crates.io/crates/no-std-compat),
+  eliminating a very outdated transitive dependency (on `hashbrown`
+  version 0.8).
+
+- Keyed state stores now allow specifying the hasher.
+  ([#262](https://github.com/boinkor-net/governor/pull/262) -
+  thanks, @0xdeafbeef!)
+
 ## [[0.8.1](https://docs.rs/governor/0.8.1/governor/)] - 2025-02-25
 
 ## Changed

governor/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "governor"
-version = "0.8.1"
+version = "0.9.0"
 authors = ["Andreas Fuchs <asf@boinkor.net>"]
 edition = "2018"
 license = "MIT"
@@ -30,7 +30,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [dev-dependencies]
 criterion = {version = "0.5.1", features = ["html_reports"]}
-tynm = "0.1.4"
+tynm = "0.2.0"
 crossbeam = "0.8.0"
 libc = "0.2.70"
 futures-executor = "0.3.31"
@@ -40,9 +40,9 @@ assertables = "9.5.0"
 [features]
 default = ["std", "dashmap", "jitter", "quanta"]
 quanta = ["dep:quanta"]
-std = ["no-std-compat/std", "nonzero_ext/std", "dep:futures-timer", "dep:futures-util", "dep:futures-sink", "dep:parking_lot"]
+std = ["nonzero_ext/std", "dep:futures-timer", "dep:futures-util", "dep:futures-sink", "dep:parking_lot"]
 jitter = ["rand"]
-no_std = ["no-std-compat/compat_hash"]
+no_std = ["hashbrown/alloc"]
 
 [dependencies]
 nonzero_ext = { version = "0.3.0", default-features = false }
@@ -56,9 +56,9 @@ rand = { version = "0.9.0", optional = true }
 getrandom = { version = "0.3", features = ["wasm_js"] }
 dashmap = { version = "6.1.0", optional = true }
 quanta = { version = "0.12.0", optional = true }
-no-std-compat = { version = "0.4.1", features = [ "alloc" ] }
 cfg-if = "1.0"
 
 # To ensure we don't pull in vulnerable smallvec, see https://github.com/antifuchs/governor/issues/60
 smallvec = "1.6.1"
 web-time = "1.1.0"
+hashbrown = "0.15.2"

governor/src/clock.rs

@@ -44,14 +44,14 @@
 //! }
 //! ```
 
-use std::prelude::v1::*;
-
-use std::convert::TryInto;
-use std::fmt::Debug;
-use std::ops::Add;
-use std::sync::atomic::Ordering;
-use std::sync::Arc;
-use std::time::Duration;
+use core::prelude::v1::*;
+
+use alloc::sync::Arc;
+use core::convert::TryInto;
+use core::fmt::Debug;
+use core::ops::Add;
+use core::sync::atomic::Ordering;
+use core::time::Duration;
 
 use portable_atomic::AtomicU64;
 

governor/src/errors.rs

@@ -1,4 +1,4 @@
-use std::fmt;
+use core::fmt;
 
 /// Error indicating that the number of cells tested (the first
 /// argument) is larger than the bucket's capacity.

governor/src/gcra.rs

@@ -2,9 +2,9 @@ use crate::state::StateStore;
 use crate::InsufficientCapacity;
 use crate::{clock, middleware::StateSnapshot, Quota};
 use crate::{middleware::RateLimitingMiddleware, nanos::Nanos};
-use std::num::NonZeroU32;
-use std::time::Duration;
-use std::{cmp, fmt};
+use core::num::NonZeroU32;
+use core::time::Duration;
+use core::{cmp, fmt};
 
 #[cfg(feature = "std")]
 use crate::Jitter;
@@ -181,7 +181,7 @@ impl Gcra {
 mod test {
     use super::*;
     use crate::Quota;
-    use std::num::NonZeroU32;
+    use core::num::NonZeroU32;
 
     use proptest::prelude::*;
 

governor/src/jitter.rs

@@ -1,14 +1,12 @@
-use std::prelude::v1::*;
-
 use crate::nanos::Nanos;
+use core::ops::Add;
+use core::time::Duration;
 #[cfg(feature = "jitter")]
 use rand::distr::uniform::{SampleBorrow, SampleUniform, UniformInt, UniformSampler};
 #[cfg(feature = "jitter")]
 use rand::distr::{Distribution, Uniform};
 #[cfg(feature = "jitter")]
 use rand::{rng, Rng};
-use std::ops::Add;
-use std::time::Duration;
 
 #[cfg(feature = "std")]
 use std::time::Instant;

governor/src/lib.rs

@@ -35,7 +35,7 @@
 // Unfortunately necessary, otherwise features aren't supported in doctests:
 #![allow(clippy::needless_doctest_main)]
 
-extern crate no_std_compat as std;
+extern crate alloc;
 
 pub mod r#_guide;
 pub mod clock;
@@ -83,4 +83,5 @@ pub type DefaultDirectRateLimiter<
 pub type DefaultKeyedRateLimiter<
     K,
     MW = middleware::NoOpMiddleware<<clock::DefaultClock as clock::Clock>::Instant>,
-> = RateLimiter<K, state::keyed::DefaultKeyedStateStore<K>, clock::DefaultClock, MW>;
+    S = state::keyed::DefaultHasher,
+> = RateLimiter<K, state::keyed::DefaultKeyedStateStore<K, S>, clock::DefaultClock, MW>;

governor/src/middleware.rs

@@ -64,7 +64,7 @@
 //!
 //! You can define your own middleware by `impl`ing [`RateLimitingMiddleware`].
 use core::fmt;
-use std::{cmp, marker::PhantomData};
+use core::{cmp, marker::PhantomData};
 
 use crate::{clock, nanos::Nanos, NotUntil, Quota};
 
@@ -219,7 +219,7 @@ pub struct NoOpMiddleware<P: clock::Reference = <clock::DefaultClock as clock::C
     phantom: PhantomData<P>,
 }
 
-impl<P: clock::Reference> std::fmt::Debug for NoOpMiddleware<P> {
+impl<P: clock::Reference> core::fmt::Debug for NoOpMiddleware<P> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "NoOpMiddleware")
     }

governor/src/nanos.rs

@@ -2,11 +2,10 @@
 
 use crate::clock;
 
-use std::convert::TryInto;
-use std::fmt;
-use std::ops::{Add, Div, Mul};
-use std::prelude::v1::*;
-use std::time::Duration;
+use core::convert::TryInto;
+use core::fmt;
+use core::ops::{Add, Div, Mul};
+use core::time::Duration;
 
 /// A number of nanoseconds from a reference point.
 ///

governor/src/quota.rs

@@ -1,8 +1,6 @@
-use std::prelude::v1::*;
-
+use core::num::NonZeroU32;
+use core::time::Duration;
 use nonzero_ext::nonzero;
-use std::num::NonZeroU32;
-use std::time::Duration;
 
 use crate::nanos::Nanos;
 

governor/src/state.rs

@@ -1,6 +1,6 @@
 //! State stores for rate limiters
 
-use std::{marker::PhantomData, prelude::v1::*};
+use core::marker::PhantomData;
 
 pub mod direct;
 mod in_memory;

governor/src/state/direct.rs

@@ -3,9 +3,7 @@
 //! Rate limiters based on these types are constructed with
 //! [the `RateLimiter` constructors](../struct.RateLimiter.html#direct-in-memory-rate-limiters---constructors)
 
-use std::prelude::v1::*;
-
-use std::num::NonZeroU32;
+use core::num::NonZeroU32;
 
 use crate::{
     clock,

governor/src/state/in_memory.rs

@@ -1,12 +1,10 @@
-use std::prelude::v1::*;
-
 use crate::nanos::Nanos;
 use crate::state::{NotKeyed, StateStore};
-use std::fmt;
-use std::fmt::Debug;
-use std::num::NonZeroU64;
-use std::sync::atomic::Ordering;
-use std::time::Duration;
+use core::fmt;
+use core::fmt::Debug;
+use core::num::NonZeroU64;
+use core::sync::atomic::Ordering;
+use core::time::Duration;
 
 use portable_atomic::AtomicU64;
 
@@ -135,6 +133,7 @@ mod test {
 
     #[test]
     fn in_memory_state_impls() {
+        use alloc::format;
         let state = InMemoryState(AtomicU64::new(0));
         assert_gt!(format!("{:?}", state).len(), 0);
     }

governor/src/state/keyed.rs

@@ -7,9 +7,9 @@
 //! Rate limiters based on these types are constructed with
 //! [the `RateLimiter` constructors](../struct.RateLimiter.html#keyed-rate-limiters---default-constructors)
 
-use std::hash::Hash;
-use std::num::NonZeroU32;
-use std::prelude::v1::*;
+use core::hash::Hash;
+use core::num::NonZeroU32;
+use core::prelude::v1::*;
 
 use crate::state::StateStore;
 use crate::{
@@ -20,6 +20,11 @@ use crate::{
     Quota, RateLimiter,
 };
 
+#[cfg(feature = "std")]
+pub type DefaultHasher = std::hash::RandomState;
+#[cfg(not(feature = "std"))]
+pub type DefaultHasher = hashbrown::DefaultHashBuilder;
+
 /// A trait for state stores with one rate limiting state per key.
 ///
 /// This is blanket-implemented by all [`StateStore`]s with hashable (`Eq + Hash + Clone`) key
@@ -64,20 +69,67 @@ where
     }
 }
 
+#[cfg(any(all(feature = "std", not(feature = "dashmap")), not(feature = "std")))]
+/// # Keyed rate limiters with custom hashers for std HashMap
+impl<K, S> RateLimiter<K, DefaultKeyedStateStore<K, S>, clock::DefaultClock>
+where
+    K: Clone + Hash + Eq,
+    S: core::hash::BuildHasher + Default,
+{
+    /// Constructs a new keyed rate limiter explicitly backed by a
+    /// [`HashMap`][hashmap::HashMap] with a custom hasher.
+    pub fn hashmap_with_hasher(quota: Quota, hasher: S) -> Self {
+        let state = HashMapStateStore::new(hashmap::HashMap::with_hasher(hasher));
+        let clock = clock::DefaultClock::default();
+        RateLimiter::new(quota, state, clock)
+    }
+}
+
+#[cfg(all(feature = "std", feature = "dashmap"))]
+/// # Keyed rate limiters with custom hashers
+impl<K, S> RateLimiter<K, DefaultKeyedStateStore<K, S>, clock::DefaultClock>
+where
+    K: Clone + Hash + Eq,
+    S: core::hash::BuildHasher + Clone + Default,
+{
+    /// Constructs a new keyed rate limiter explicitly backed by a
+    /// [`DashMap`][::dashmap::DashMap] with a custom hasher.
+    pub fn dashmap_with_hasher(quota: Quota, hasher: S) -> Self {
+        let state = DashMapStateStore::with_hasher(hasher);
+        let clock = clock::DefaultClock::default();
+        RateLimiter::new(quota, state, clock)
+    }
+}
+
 #[cfg(all(feature = "std", feature = "dashmap"))]
 impl<K> RateLimiter<K, HashMapStateStore<K>, clock::DefaultClock>
 where
     K: Clone + Hash + Eq,
 {
     /// Constructs a new keyed rate limiter explicitly backed by a
-    /// [`HashMap`][std::collections::HashMap].
+    /// [`HashMap`][hashmap::HashMap].
     pub fn hashmap(quota: Quota) -> Self {
         let state = HashMapStateStore::default();
         let clock = clock::DefaultClock::default();
         RateLimiter::new(quota, state, clock)
     }
 }
 
+#[cfg(all(feature = "std", feature = "dashmap"))]
+impl<K, S> RateLimiter<K, HashMapStateStore<K, S>, clock::DefaultClock>
+where
+    K: Clone + Hash + Eq,
+    S: core::hash::BuildHasher + Default + Clone,
+{
+    /// Constructs a new keyed rate limiter explicitly backed by a
+    /// [`HashMap`][hashmap::HashMap].
+    pub fn hashmap_with_hasher(quota: Quota, hasher: S) -> Self {
+        let state = HashMapStateStore::new(hashmap::HashMap::with_hasher(hasher));
+        let clock = clock::DefaultClock::default();
+        RateLimiter::new(quota, state, clock)
+    }
+}
+
 /// # Keyed rate limiters - Manually checking cells
 impl<K, S, C, MW> RateLimiter<K, S, C, MW>
 where
@@ -224,16 +276,16 @@ pub use self::dashmap::DashMapStateStore;
 mod future;
 
 #[cfg(any(all(feature = "std", not(feature = "dashmap")), not(feature = "std")))]
-/// The default keyed rate limiter type: a mutex-wrapped [`HashMap`][std::collections::HashMap].
-pub type DefaultKeyedStateStore<K> = HashMapStateStore<K>;
+/// The default keyed rate limiter type: a mutex-wrapped [`HashMap`][hashmap::Hashmap].
+pub type DefaultKeyedStateStore<K, S = DefaultHasher> = HashMapStateStore<K, S>;
 
 #[cfg(all(feature = "std", feature = "dashmap"))]
 /// The default keyed rate limiter type: the concurrent [`DashMap`][::dashmap::DashMap].
-pub type DefaultKeyedStateStore<K> = DashMapStateStore<K>;
+pub type DefaultKeyedStateStore<K, S = DefaultHasher> = DashMapStateStore<K, S>;
 
 #[cfg(test)]
 mod test {
-    use std::marker::PhantomData;
+    use core::marker::PhantomData;
 
     use nonzero_ext::nonzero;