release 0.55.0

Author: jaemk

CHANGELOG.md

@@ -5,6 +5,17 @@
 ## Changed
 ## Removed
 
+## [0.55.0]
+## Added
+- Add `sync_writes = "by_key"` support to `#[cached]
+## Changed
+- Update `redis` to 0.29.0
+- Update `directories` to 6.0
+- Update `thiserror` to 2.0
+- With the `sync_writes = "by_key"` addition, the argument values changed from a boolean
+  to strings. The equivalent of `sync_writes = true` is now `sync_writes = "default"`
+## Removed
+
 ## [0.54.0]
 ## Added
 - Add `Cached::cache_try_get_or_set_with` for parity with async trait

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cached"
-version = "0.54.0"
+version = "0.55.0"
 authors = ["James Kominick <[email protected]>"]
 description = "Generic cache implementations and simplified function memoization"
 repository = "https://github.com/jaemk/cached"

README.md

@@ -14,7 +14,7 @@ function-cache wrapped in a mutex/rwlock, or externally synchronized in the case
 By default, the function-cache is **not** locked for the duration of the function's execution, so initial (on an empty cache)
 concurrent calls of long-running functions with the same arguments will each execute fully and each overwrite
 the memoized value as they complete. This mirrors the behavior of Python's `functools.lru_cache`. To synchronize the execution and caching
-of un-cached arguments, specify `#[cached(sync_writes = "default")]` / `#[once(sync_writes = "default")]` (not supported by `#[io_cached]`.
+of un-cached arguments, specify `#[cached(sync_writes = "default")]` / `#[once(sync_writes = true)]` (not supported by `#[io_cached]`.
 
 - See [`cached::stores` docs](https://docs.rs/cached/latest/cached/stores/index.html) cache stores available.
 - See [`proc_macro`](https://docs.rs/cached/latest/cached/proc_macro/index.html) for more procedural macro examples.
@@ -93,7 +93,7 @@ use cached::proc_macro::once;
 /// When no (or expired) cache, concurrent calls
 /// will synchronize (`sync_writes`) so the function
 /// is only executed once.
-#[once(time=10, option = true, sync_writes = "default")]
+#[once(time=10, option = true, sync_writes = true)]
 fn keyed(a: String) -> Option<usize> {
     if a == "a" {
         Some(a.len())

cached_proc_macro/src/lib.rs

@@ -13,8 +13,10 @@ use proc_macro::TokenStream;
 /// - `size`: (optional, usize) specify an LRU max size, implies the cache type is a `SizedCache` or `TimedSizedCache`.
 /// - `time`: (optional, u64) specify a cache TTL in seconds, implies the cache type is a `TimedCache` or `TimedSizedCache`.
 /// - `time_refresh`: (optional, bool) specify whether to refresh the TTL on cache hits.
-/// - `sync_writes`: (optional, bool) specify whether to synchronize the execution of writing of uncached values.
-/// - `sync_writes_by_key`: (optional, bool) specify whether to synchronize the execution of writing of uncached values by key.
+/// - `sync_writes`: (optional, string) specify whether to synchronize the execution and writing of uncached values.
+///    When not specified, the `"default"` behavior will synchronize all keys, locking the whole cache during an
+///    uncached execution. When set to `"by_key"` a per-key lock is used to synchronize uncached execution of
+///    duplicate keys only.
 /// - `ty`: (optional, string type) The cache store type to use. Defaults to `UnboundCache`. When `unbound` is
 ///   specified, defaults to `UnboundCache`. When `size` is specified, defaults to `SizedCache`.
 ///   When `time` is specified, defaults to `TimedCached`.

cached_proc_macro/src/once.rs

@@ -6,20 +6,14 @@ use quote::quote;
 use syn::spanned::Spanned;
 use syn::{parse_macro_input, Ident, ItemFn, ReturnType};
 
-#[derive(Debug, Default, FromMeta)]
-enum SyncWriteMode {
-    #[default]
-    Default,
-}
-
 #[derive(FromMeta)]
 struct OnceMacroArgs {
     #[darling(default)]
     name: Option<String>,
     #[darling(default)]
     time: Option<u64>,
     #[darling(default)]
-    sync_writes: Option<SyncWriteMode>,
+    sync_writes: bool,
     #[darling(default)]
     result: bool,
     #[darling(default)]
@@ -226,22 +220,23 @@ pub fn once(args: TokenStream, input: TokenStream) -> TokenStream {
         }
     };
 
-    let do_set_return_block = match args.sync_writes {
-        Some(SyncWriteMode::Default) => quote! {
+    let do_set_return_block = if args.sync_writes {
+        quote! {
             #r_lock_return_cache_block
             #w_lock
             if let Some(result) = &*cached {
                 #return_cache_block
             }
             #function_call
             #set_cache_and_return
-        },
-        None => quote! {
+        }
+    } else {
+        quote! {
             #r_lock_return_cache_block
             #function_call
             #w_lock
             #set_cache_and_return
-        },
+        }
     };
 
     let signature_no_muts = get_mut_signature(signature);

examples/async_std.rs

@@ -86,7 +86,7 @@ async fn only_cached_once_per_second(s: String) -> Vec<String> {
 /// _one_ call will be "executed" and all others will be synchronized
 /// to return the cached result of the one call instead of all
 /// concurrently un-cached tasks executing and writing concurrently.
-#[once(time = 2, sync_writes = "default")]
+#[once(time = 2, sync_writes = true)]
 async fn only_cached_once_per_second_sync_writes(s: String) -> Vec<String> {
     vec![s]
 }

src/lib.rs

@@ -13,7 +13,7 @@ function-cache wrapped in a mutex/rwlock, or externally synchronized in the case
 By default, the function-cache is **not** locked for the duration of the function's execution, so initial (on an empty cache)
 concurrent calls of long-running functions with the same arguments will each execute fully and each overwrite
 the memoized value as they complete. This mirrors the behavior of Python's `functools.lru_cache`. To synchronize the execution and caching
-of un-cached arguments, specify `#[cached(sync_writes = "default")]` / `#[once(sync_writes = "default")]` (not supported by `#[io_cached]`.
+of un-cached arguments, specify `#[cached(sync_writes = "default")]` / `#[once(sync_writes = true)]` (not supported by `#[io_cached]`.
 
 - See [`cached::stores` docs](https://docs.rs/cached/latest/cached/stores/index.html) cache stores available.
 - See [`proc_macro`](https://docs.rs/cached/latest/cached/proc_macro/index.html) for more procedural macro examples.
@@ -94,7 +94,7 @@ use cached::proc_macro::once;
 /// When no (or expired) cache, concurrent calls
 /// will synchronize (`sync_writes`) so the function
 /// is only executed once.
-#[once(time=10, option = true, sync_writes = "default")]
+#[once(time=10, option = true, sync_writes = true)]
 fn keyed(a: String) -> Option<usize> {
     if a == "a" {
         Some(a.len())

src/proc_macro.rs

@@ -233,7 +233,7 @@ use cached::proc_macro::once;
 /// When no (or expired) cache, concurrent calls
 /// will synchronize (`sync_writes`) so the function
 /// is only executed once.
-#[once(time=10, option = true, sync_writes = "default")]
+#[once(time=10, option = true, sync_writes = true)]
 fn keyed(a: String) -> Option<usize> {
     if a == "a" {
         Some(a.len())

tests/cached.rs

@@ -328,6 +328,7 @@ cached_control! {
     Key = { input.to_owned() };
     PostGet(cached_val) = return Ok(cached_val.clone());
     PostExec(body_result) = {
+        #[allow(clippy::question_mark)]
         match body_result {
             Ok(v) => v,
             Err(e) => return Err(e),
@@ -848,7 +849,7 @@ async fn test_only_cached_option_once_per_second_a() {
 /// to return the cached result of the one call instead of all
 /// concurrently un-cached tasks executing and writing concurrently.
 #[cfg(feature = "async")]
-#[once(time = 2, sync_writes = "default")]
+#[once(time = 2, sync_writes)]
 async fn only_cached_once_per_second_sync_writes(s: String) -> Vec<String> {
     vec![s]
 }
@@ -910,9 +911,9 @@ fn test_cached_sync_writes_by_key() {
     let b = std::thread::spawn(|| cached_sync_writes_by_key("b".to_string()));
     let c = std::thread::spawn(|| cached_sync_writes_by_key("c".to_string()));
     let start = Instant::now();
-    let a = a.join().unwrap();
-    let b = b.join().unwrap();
-    let c = c.join().unwrap();
+    let _ = a.join().unwrap();
+    let _ = b.join().unwrap();
+    let _ = c.join().unwrap();
     assert!(start.elapsed() < Duration::from_secs(2));
 }
 
@@ -942,7 +943,7 @@ async fn test_cached_sync_writes_by_key_a() {
 }
 
 #[cfg(feature = "async")]
-#[once(sync_writes = "default")]
+#[once(sync_writes = true)]
 async fn once_sync_writes_a(s: &tokio::sync::Mutex<String>) -> String {
     let mut guard = s.lock().await;
     let results: String = (*guard).clone().to_string();