lix 0.18.0

Embeddable version control for apps and AI agents.
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

//! Safety obligations for conversion and backing-storage session Send assertions.
use super::*;
use crate::session::borrowing_proof_storage::{BorrowingRead, BorrowingStorage};
use crate::storage_adapter::{SharedStorageAdapterRead, StorageAdapterReadScope};
fn is_send<T: Send>(_: &T) {}
fn assert_send<T: Send + ?Sized>() {}
fn assert_sync<T: Sync + ?Sized>() {}

#[test]
fn complete_unwrapped_memory_conversion_future_is_send() {
    let raw = convert_full_replica_owned(
        Memory::new(),
        ServerOptions::new("https://example.invalid/lix/test"),
        Some(uuid::Uuid::nil().to_string()),
    );
    is_send(&raw);
}

#[tokio::test]
async fn complete_unwrapped_memory_storage_session_future_is_send() {
    let storage = Memory::new();
    let source = open_lix().with_storage(storage.clone()).await.unwrap();
    is_send(&source.open_storage_session_inner(storage.clone()));
    is_send(&source.open_storage_session(storage.clone()));
    let child = source.open_storage_session(storage).await.unwrap();
    child.execute("SELECT 1", &[]).await.unwrap();
    child.close().await.unwrap();
    source.close().await.unwrap();
}

// A free lifetime proves these obligations universally, rather than only at
// 'static. The actual borrowing adapter reproduces native RocksDB/Filesystem
// read-handle lifetimes; whole-future inference at this shape is the compiler
// limitation documented by session::assume_send_future_proofs_borrowing.
#[allow(dead_code)]
fn native_storage_obligations<'a, S: Storage + Clone + Send + Sync + 'static>() {
    assert_send::<S::Read<'a>>();
    assert_sync::<S::Read<'a>>();
    assert_send::<S::Write<'a>>();
    assert_send::<StorageAdapterReadScope<S::Read<'a>>>();
    assert_sync::<StorageAdapterReadScope<S::Read<'a>>>();
    assert_send::<SharedStorageAdapterRead<S::Read<'a>>>();
    assert_sync::<SharedStorageAdapterRead<S::Read<'a>>>();
    assert_send::<StorageSession<S>>();
    assert_sync::<StorageSession<S>>();
    assert_sync::<crate::storage_adapter::StorageAdapter<S>>();
    assert_send::<Lix<S>>();
    assert_sync::<Lix<S>>();
}
#[allow(dead_code)]
fn borrowing_adapter_obligations<'a>() {
    native_storage_obligations::<BorrowingStorage>();
    assert_send::<SharedStorageAdapterRead<BorrowingRead<'a>>>();
    assert_sync::<SharedStorageAdapterRead<BorrowingRead<'a>>>();
}
#[test]
fn owned_and_borrowed_capture_types_meet_send_contract() {
    assert_send::<ServerOptions>();
    assert_sync::<ServerOptions>();
    assert_send::<crate::storage::StorageOwnerLease>();
    assert_sync::<bytes::Bytes>();
    assert_sync::<Arc<dyn OpenProgressSink>>();
    assert_sync::<crate::sync::InspectedFullConversion>();
    assert_sync::<crate::sync::AuthenticatedPartialConversion>();
    assert_sync::<crate::sync::PartialReplicaState>();
    assert_send::<crate::migration::PendingConversionJournal>();
    assert_send::<crate::migration::GlobalConversionJournal>();
}