automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/src/columnar/encoding/encodable_impls.rs

@@ -0,0 +1,200 @@
+use super::{Encodable, Sink};
+
+use std::borrow::Cow;
+
+use smol_str::SmolStr;
+
+/// Encodes bytes without a length prefix
+pub(crate) struct RawBytes<'a>(Cow<'a, [u8]>);
+
+impl<'a> From<&'a [u8]> for RawBytes<'a> {
+    fn from(r: &'a [u8]) -> Self {
+        RawBytes(r.into())
+    }
+}
+
+impl<'a> From<Cow<'a, [u8]>> for RawBytes<'a> {
+    fn from(c: Cow<'a, [u8]>) -> Self {
+        RawBytes(c)
+    }
+}
+
+impl Encodable for RawBytes<'_> {
+    fn encode<S: Sink>(&self, out: &mut S) -> usize {
+        out.append(&self.0);
+        self.0.len()
+    }
+}
+
+impl Encodable for SmolStr {
+    fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+        let bytes = self.as_bytes();
+        let len_encoded = bytes.len().encode(buf);
+        let data_len = bytes.encode(buf);
+        len_encoded + data_len
+    }
+}
+
+impl Encodable for Cow<'_, SmolStr> {
+    fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+        self.as_ref().encode(buf)
+    }
+}
+
+impl Encodable for String {
+    fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+        let bytes = self.as_bytes();
+        let len_encoded = bytes.len().encode(buf);
+        let data_len = bytes.encode(buf);
+        len_encoded + data_len
+    }
+}
+
+impl Encodable for Option<String> {
+    fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+        if let Some(s) = self {
+            s.encode(buf)
+        } else {
+            0.encode(buf)
+        }
+    }
+}
+
+impl Encodable for Option<Cow<'_, SmolStr>> {
+    fn encode<S: Sink>(&self, out: &mut S) -> usize {
+        if let Some(s) = self {
+            SmolStr::encode(s, out)
+        } else {
+            0.encode(out)
+        }
+    }
+}
+
+impl Encodable for f64 {
+    fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+        let bytes = self.to_le_bytes();
+        buf.append(&bytes);
+        bytes.len()
+    }
+}
+
+impl Encodable for f32 {
+    fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+        let bytes = self.to_le_bytes();
+        buf.append(&bytes);
+        bytes.len()
+    }
+}
+
+impl Encodable for usize {
+    fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+        (*self as u64).encode(buf)
+    }
+}
+
+impl Encodable for u32 {
+    fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+        u64::from(*self).encode(buf)
+    }
+}
+
+impl Encodable for i32 {
+    fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+        i64::from(*self).encode(buf)
+    }
+}
+
+impl Encodable for [u8] {
+    fn encode<S: Sink>(&self, out: &mut S) -> usize {
+        out.append(self);
+        self.len()
+    }
+}
+
+impl Encodable for &[u8] {
+    fn encode<S: Sink>(&self, out: &mut S) -> usize {
+        out.append(self);
+        self.len()
+    }
+}
+
+impl Encodable for Cow<'_, [u8]> {
+    fn encode<S: Sink>(&self, out: &mut S) -> usize {
+        out.append(self);
+        self.len()
+    }
+}
+
+impl Encodable for Vec<u8> {
+    fn encode<S: Sink>(&self, out: &mut S) -> usize {
+        Encodable::encode(&self[..], out)
+    }
+}
+
+mod leb128_things {
+    use super::{Encodable, Sink};
+
+    impl Encodable for u64 {
+        fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+            let mut val = *self;
+            let mut bytes_written = 0;
+            loop {
+                let mut byte = low_bits_of_u64(val);
+                val >>= 7;
+                if val != 0 {
+                    // More bytes to come, so set the continuation bit.
+                    byte |= CONTINUATION_BIT;
+                }
+
+                buf.append(&[byte]);
+                bytes_written += 1;
+
+                if val == 0 {
+                    return bytes_written;
+                }
+            }
+        }
+    }
+
+    impl Encodable for i64 {
+        fn encode<S: Sink>(&self, buf: &mut S) -> usize {
+            let mut val = *self;
+            let mut bytes_written = 0;
+            loop {
+                let mut byte = val as u8;
+                // Keep the sign bit for testing
+                val >>= 6;
+                let done = val == 0 || val == -1;
+                if done {
+                    byte &= !CONTINUATION_BIT;
+                } else {
+                    // Remove the sign bit
+                    val >>= 1;
+                    // More bytes to come, so set the continuation bit.
+                    byte |= CONTINUATION_BIT;
+                }
+
+                buf.append(&[byte]);
+                bytes_written += 1;
+
+                if done {
+                    return bytes_written;
+                }
+            }
+        }
+    }
+
+    #[doc(hidden)]
+    const CONTINUATION_BIT: u8 = 1 << 7;
+
+    #[inline]
+    fn low_bits_of_byte(byte: u8) -> u8 {
+        byte & !CONTINUATION_BIT
+    }
+
+    #[inline]
+    fn low_bits_of_u64(val: u64) -> u8 {
+        let byte = val & (u8::MAX as u64);
+        low_bits_of_byte(byte as u8)
+    }
+}

data/vendor/automerge-rust/automerge/src/columnar/encoding/leb128.rs

@@ -0,0 +1,82 @@
+/// The number of bytes required to encode `val` as a LEB128 integer
+pub(crate) fn lebsize(mut val: i64) -> u64 {
+    if val < 0 {
+        val = !val
+    }
+    // 1 extra for the sign bit
+    leb_bytes(1 + 64 - val.leading_zeros() as u64)
+}
+
+/// The number of bytes required to encode `val` as a uLEB128 integer
+pub(crate) fn ulebsize(val: u64) -> u64 {
+    if val == 0 {
+        return 1;
+    }
+    leb_bytes(64 - val.leading_zeros() as u64)
+}
+
+fn leb_bytes(bits: u64) -> u64 {
+    bits.div_ceil(7)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        fn test_ulebsize(val in 0..u64::MAX) {
+            let mut out = Vec::new();
+            leb128::write::unsigned(&mut out, val).unwrap();
+            let expected = out.len() as u64;
+            assert_eq!(expected, ulebsize(val))
+        }
+
+        #[test]
+        fn test_lebsize(val in i64::MIN..i64::MAX) {
+            let mut out = Vec::new();
+            leb128::write::signed(&mut out, val).unwrap();
+            let expected = out.len() as u64;
+            assert_eq!(expected, lebsize(val))
+        }
+    }
+
+    #[test]
+    fn ulebsize_examples() {
+        let scenarios = vec![0, 1, 127, 128, 129, 169, u64::MAX];
+        for val in scenarios {
+            let mut out = Vec::new();
+            leb128::write::unsigned(&mut out, val).unwrap();
+            let expected = out.len() as u64;
+            assert_eq!(ulebsize(val), expected, "value: {}", val)
+        }
+    }
+
+    #[test]
+    fn lebsize_examples() {
+        let scenarios = vec![
+            0,
+            1,
+            -1,
+            63,
+            64,
+            -64,
+            -65,
+            127,
+            128,
+            -127,
+            -128,
+            -2097152,
+            169,
+            i64::MIN,
+            i64::MAX,
+        ];
+        for val in scenarios {
+            let mut out = Vec::new();
+            leb128::write::signed(&mut out, val).unwrap();
+            let expected = out.len() as u64;
+            assert_eq!(lebsize(val), expected, "value: {}", val)
+        }
+    }
+}

data/vendor/automerge-rust/automerge/src/columnar/encoding/properties.rs

@@ -0,0 +1,178 @@
+//! Helpers for property tests.
+
+use std::{fmt::Debug, ops::Range};
+
+use proptest::prelude::*;
+use smol_str::SmolStr;
+
+use crate::{
+    columnar::Key,
+    types::{ElemId, OpId, ScalarValue},
+};
+
+#[derive(Clone, Debug)]
+pub(crate) struct SpliceScenario<T> {
+    pub(crate) initial_values: Vec<T>,
+    pub(crate) replace_range: Range<usize>,
+    pub(crate) replacements: Vec<T>,
+}
+
+impl<T: Debug + PartialEq + Clone> SpliceScenario<T> {
+    pub(crate) fn check(&self, results: Vec<T>) {
+        let mut expected = self.initial_values.clone();
+        expected.splice(self.replace_range.clone(), self.replacements.clone());
+        assert_eq!(expected, results)
+    }
+}
+
+impl<T: Debug + PartialEq + Clone> SpliceScenario<Option<T>> {
+    /// Checks that `results` are the same as `SpliceScenario::initial_values.splice(replace_range,
+    /// replacements)`, with two slight changes:
+    ///
+    /// * If all of `initial_values` are `None` then this returns true if the output is just
+    ///   `replacements`
+    /// * If the result of `Vec::splice` would return a vector of all `None` then this checks the
+    ///   result is actually an empty vector
+    ///
+    /// This is to accomodate the fact that the RLE encoder can encode a sequence of all `None` as
+    /// an empty sequence, in which case we decode it as an empty sequence.
+    pub(crate) fn check_optional(&self, results: Vec<Option<T>>) {
+        if self.initial_values.iter().all(|v| v.is_none()) {
+            if self.replacements.iter().all(|v| v.is_none()) {
+                assert!(results.is_empty());
+            } else {
+                assert_eq!(results, self.replacements);
+            }
+        } else {
+            let mut expected = self.initial_values.clone();
+            expected.splice(self.replace_range.clone(), self.replacements.clone());
+            if expected.iter().all(|e| e.is_none()) {
+                assert!(results.is_empty())
+            } else {
+                assert_eq!(expected, results)
+            }
+        }
+    }
+}
+
+pub(crate) fn splice_scenario<S: Strategy<Value = T> + Clone, T: Debug + Clone + 'static>(
+    item_strat: S,
+) -> impl Strategy<Value = SpliceScenario<T>> {
+    (
+        proptest::collection::vec(item_strat.clone(), 0..100),
+        proptest::collection::vec(item_strat, 0..10),
+    )
+        .prop_flat_map(move |(values, to_splice)| {
+            if values.is_empty() {
+                Just(SpliceScenario {
+                    initial_values: values,
+                    replace_range: 0..0,
+                    replacements: to_splice,
+                })
+                .boxed()
+            } else {
+                // This is somewhat awkward to write because we have to carry the `values` and
+                // `to_splice` through as `Just(..)` to please the borrow checker.
+                (0..values.len(), Just(values), Just(to_splice))
+                    .prop_flat_map(move |(replace_range_start, values, to_splice)| {
+                        (
+                            0..(values.len() - replace_range_start),
+                            Just(values),
+                            Just(to_splice),
+                        )
+                            .prop_map(
+                                move |(replace_range_len, values, to_splice)| SpliceScenario {
+                                    initial_values: values,
+                                    replace_range: replace_range_start
+                                        ..(replace_range_start + replace_range_len),
+                                    replacements: to_splice,
+                                },
+                            )
+                    })
+                    .boxed()
+            }
+        })
+}
+
+/// Like splice scenario except that if the initial values we generate are all `None` then the
+/// replace range is 0..0.
+pub(crate) fn option_splice_scenario<
+    S: Strategy<Value = Option<T>> + Clone,
+    T: Debug + Clone + 'static,
+>(
+    item_strat: S,
+) -> impl Strategy<Value = SpliceScenario<Option<T>>> {
+    (
+        proptest::collection::vec(item_strat.clone(), 0..100),
+        proptest::collection::vec(item_strat, 0..10),
+    )
+        .prop_flat_map(move |(values, to_splice)| {
+            if values.is_empty() || values.iter().all(|v| v.is_none()) {
+                Just(SpliceScenario {
+                    initial_values: values,
+                    replace_range: 0..0,
+                    replacements: to_splice,
+                })
+                .boxed()
+            } else {
+                // This is somewhat awkward to write because we have to carry the `values` and
+                // `to_splice` through as `Just(..)` to please the borrow checker.
+                (0..values.len(), Just(values), Just(to_splice))
+                    .prop_flat_map(move |(replace_range_start, values, to_splice)| {
+                        (
+                            0..(values.len() - replace_range_start),
+                            Just(values),
+                            Just(to_splice),
+                        )
+                            .prop_map(
+                                move |(replace_range_len, values, to_splice)| SpliceScenario {
+                                    initial_values: values,
+                                    replace_range: replace_range_start
+                                        ..(replace_range_start + replace_range_len),
+                                    replacements: to_splice,
+                                },
+                            )
+                    })
+                    .boxed()
+            }
+        })
+}
+
+pub(crate) fn opid() -> impl Strategy<Value = OpId> + Clone {
+    (0..(u32::MAX as usize), 0..(u32::MAX as u64)).prop_map(|(actor, ctr)| OpId::new(ctr, actor))
+}
+
+pub(crate) fn elemid() -> impl Strategy<Value = ElemId> + Clone {
+    opid().prop_map(ElemId)
+}
+
+pub(crate) fn key() -> impl Strategy<Value = Key> + Clone {
+    prop_oneof! {
+        elemid().prop_map(Key::Elem),
+        any::<String>().prop_map(|s| Key::Prop(s.into())),
+    }
+}
+
+pub(crate) fn encodable_int() -> impl Strategy<Value = i64> + Clone {
+    let bounds = i64::MAX / 2;
+    -bounds..bounds
+}
+
+pub(crate) fn scalar_value() -> impl Strategy<Value = ScalarValue> + Clone {
+    prop_oneof! {
+        Just(ScalarValue::Null),
+        any::<bool>().prop_map(ScalarValue::Boolean),
+        any::<u64>().prop_map(ScalarValue::Uint),
+        encodable_int().prop_map(ScalarValue::Int),
+        any::<f64>().prop_map(ScalarValue::F64),
+        smol_str().prop_map(ScalarValue::Str),
+        any::<Vec<u8>>().prop_map(ScalarValue::Bytes),
+        encodable_int().prop_map(|i| ScalarValue::Counter(i.into())),
+        encodable_int().prop_map(ScalarValue::Timestamp),
+        (10..15_u8, any::<Vec<u8>>()).prop_map(|(c, b)| ScalarValue::Unknown { type_code: c, bytes: b }),
+    }
+}
+
+fn smol_str() -> impl Strategy<Value = SmolStr> + Clone {
+    any::<String>().prop_map(SmolStr::from)
+}

data/vendor/automerge-rust/automerge/src/columnar/encoding/raw.rs

@@ -0,0 +1,101 @@
+use std::{
+    borrow::{Borrow, Cow},
+    fmt::Debug,
+};
+
+use super::{Decodable, DecodeError, Encodable, Sink};
+
+#[derive(Clone, Debug)]
+pub(crate) struct RawDecoder<'a> {
+    offset: usize,
+    last_read: usize,
+    data: Cow<'a, [u8]>,
+}
+
+#[derive(thiserror::Error, Debug)]
+pub(crate) enum Error {
+    #[error("buffer size did not change")]
+    BufferSizeDidNotChange,
+    #[error("trying to read past end")]
+    TryingToReadPastEnd,
+    #[error(transparent)]
+    Decode(#[from] DecodeError),
+}
+
+impl<'a> RawDecoder<'a> {
+    pub(crate) fn new(data: Cow<'a, [u8]>) -> Self {
+        RawDecoder {
+            offset: 0,
+            last_read: 0,
+            data,
+        }
+    }
+
+    pub(crate) fn read<T: Decodable + Debug>(&mut self) -> Result<T, Error> {
+        let mut buf = &self.data[self.offset..];
+        let init_len = buf.len();
+        let val = T::decode::<&[u8]>(&mut buf)?;
+        let delta = init_len - buf.len();
+        if delta == 0 {
+            Err(Error::BufferSizeDidNotChange)
+        } else {
+            self.last_read = delta;
+            self.offset += delta;
+            Ok(val)
+        }
+    }
+
+    pub(crate) fn read_bytes(&mut self, index: usize) -> Result<&[u8], Error> {
+        if self.offset + index > self.data.len() {
+            Err(Error::TryingToReadPastEnd)
+        } else {
+            let head = &self.data[self.offset..self.offset + index];
+            self.last_read = index;
+            self.offset += index;
+            Ok(head)
+        }
+    }
+
+    pub(crate) fn done(&self) -> bool {
+        self.offset >= self.data.len()
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+}
+
+impl<'a> From<&'a [u8]> for RawDecoder<'a> {
+    fn from(d: &'a [u8]) -> Self {
+        Cow::Borrowed(d).into()
+    }
+}
+
+impl<'a> From<Cow<'a, [u8]>> for RawDecoder<'a> {
+    fn from(d: Cow<'a, [u8]>) -> Self {
+        RawDecoder::new(d)
+    }
+}
+
+pub(crate) struct RawEncoder<S> {
+    written: usize,
+    output: S,
+}
+
+impl<S: Sink> RawEncoder<S> {
+    pub(crate) fn append<B: Borrow<I>, I: Encodable>(&mut self, value: B) -> usize {
+        let written = value.borrow().encode(&mut self.output);
+        self.written += written;
+        written
+    }
+
+    pub(crate) fn finish(self) -> (S, usize) {
+        (self.output, self.written)
+    }
+}
+
+impl<S: Sink> From<S> for RawEncoder<S> {
+    fn from(output: S) -> Self {
+        RawEncoder { written: 0, output }
+    }
+}