easy_prefs 3.0.1

The simplest to use API we could think of to persist prefs to disk. Basically wrap a macro around a struct (see syntax), then data is saved when you write to it. Performant, testable, thread safe, easy to migrate, and careful to not corrupt your data.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use easy_prefs::easy_prefs;
use std::sync::{Arc, Mutex};
use std::thread;

easy_prefs! {
    struct ConcurrentPrefs {
        pub counter: i32 = 0 => "counter",
        pub name: String = String::new() => "name",
    },
    "concurrent-prefs"
}

#[test]
fn test_concurrent_access_with_mutex() {
    let prefs = Arc::new(Mutex::new(ConcurrentPrefs::load_testing()));
    let mut handles = vec![];

    // Spawn 10 threads that increment the counter
    for i in 0..10 {
        let prefs_clone = Arc::clone(&prefs);
        let handle = thread::spawn(move || {
            let mut prefs = prefs_clone.lock().unwrap();
            let current = *prefs.get_counter();
            prefs
                .save_counter(current + 1)
                .expect("Save should succeed");

            // Also update name
            prefs
                .save_name(format!("thread-{}", i))
                .expect("Save should succeed");
        });
        handles.push(handle);
    }

    // Wait for all threads to complete
    for handle in handles {
        handle.join().unwrap();
    }

    // Verify final state
    let prefs = prefs.lock().unwrap();
    assert_eq!(*prefs.get_counter(), 10);
    // Name should be from one of the threads (we can't predict which)
    assert!(prefs.get_name().starts_with("thread-"));
}

#[test]
fn test_edit_guard_thread_safety() {
    let mut prefs = ConcurrentPrefs::load_testing();

    // Create an edit guard
    let mut edit = prefs.edit();

    // Verify we can't move prefs to another thread while edit guard exists
    // This is a compile-time check, but we can test the behavior
    edit.set_counter(42);
    edit.set_name("test".to_string());

    // Drop the guard
    drop(edit);

    // Verify changes were saved
    assert_eq!(*prefs.get_counter(), 42);
    assert_eq!(prefs.get_name(), "test");
}

#[test]
#[should_panic(expected = "load_default() has been removed in version 3.0.0")]
fn test_load_default_removed() {
    let test_dir = format!("/tmp/easy_prefs_multi_{}", std::process::id());

    // load_default is no longer supported and should panic
    #[allow(deprecated)]
    let _prefs = ConcurrentPrefs::load_default(&test_dir);
}