automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/src/change_queue.rs

@@ -0,0 +1,46 @@
+use std::collections::HashSet;
+
+use crate::{Change, ChangeHash};
+
+/// An indexed queue of unapplied changes that are not yet causally ready.
+///
+/// Maintains a hash index so that lookups are O(1) instead of linear scans.
+#[derive(Debug, Clone)]
+pub(crate) struct ChangeQueue {
+    changes: Vec<Change>,
+    /// Set of hashes of all changes in the queue — O(1) contains check.
+    hashes: HashSet<ChangeHash>,
+}
+
+impl ChangeQueue {
+    pub(crate) fn new() -> Self {
+        Self {
+            changes: Vec::new(),
+            hashes: HashSet::new(),
+        }
+    }
+
+    pub(crate) fn push(&mut self, c: Change) {
+        self.hashes.insert(c.hash());
+        self.changes.push(c);
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.changes.is_empty()
+    }
+
+    /// O(1) check whether a change with this hash is in the queue.
+    pub(crate) fn has_hash(&self, hash: &ChangeHash) -> bool {
+        self.hashes.contains(hash)
+    }
+
+    pub(crate) fn iter(&self) -> impl Iterator<Item = &Change> {
+        self.changes.iter()
+    }
+
+    /// Take all changes out, leaving the queue empty.
+    pub(crate) fn take(&mut self) -> Vec<Change> {
+        self.hashes.clear();
+        std::mem::take(&mut self.changes)
+    }
+}

data/vendor/automerge-rust/automerge/src/clock.rs

@@ -0,0 +1,206 @@
+use crate::types::OpId;
+
+use std::num::NonZeroU32;
+
+#[derive(Default, Debug, Clone, PartialEq)]
+pub(crate) struct Clock(pub(crate) Vec<u32>);
+
+#[derive(Default, Debug, Clone, PartialEq)]
+pub(crate) struct SeqClock(pub(crate) Vec<Option<NonZeroU32>>);
+
+impl SeqClock {
+    pub(crate) fn iter(&self) -> impl Iterator<Item = (usize, Option<NonZeroU32>)> + '_ {
+        self.0.iter().copied().enumerate()
+    }
+
+    pub(crate) fn remove_actor(&mut self, idx: usize) {
+        self.0.remove(idx);
+    }
+
+    pub(crate) fn rewrite_with_new_actor(&mut self, idx: usize) {
+        self.0.insert(idx, None)
+    }
+
+    pub(crate) fn get_for_actor(&self, actor_index: &usize) -> Option<NonZeroU32> {
+        self.0.get(*actor_index).copied().flatten()
+    }
+
+    pub(crate) fn new(size: usize) -> Self {
+        Self(vec![None; size])
+    }
+
+    pub(crate) fn include(&mut self, actor_idx: usize, data: Option<u32>) -> bool {
+        if let Some(data) = data {
+            match self.0[actor_idx] {
+                None => {
+                    self.0[actor_idx] = NonZeroU32::try_from(data).ok();
+                    true
+                }
+                Some(old_data) if old_data.get() < data => {
+                    self.0[actor_idx] = NonZeroU32::try_from(data).ok();
+                    true
+                }
+                _ => false,
+            }
+        } else {
+            false
+        }
+    }
+
+    pub(crate) fn merge(a: &mut Self, b: &Self) {
+        for (a, b) in std::iter::zip(a.0.iter_mut(), b.0.iter()) {
+            if *a < *b {
+                *a = *b;
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum ClockRange {
+    Current(Option<Clock>),
+    Diff(Clock, Clock),
+}
+
+impl Default for ClockRange {
+    fn default() -> Self {
+        Self::Current(None)
+    }
+}
+
+impl ClockRange {
+    pub(crate) fn current(clock: Option<Clock>) -> Self {
+        Self::Current(clock)
+    }
+
+    pub(crate) fn after(&self) -> Option<&Clock> {
+        match self {
+            Self::Diff(_, after) => Some(after),
+            Self::Current(Some(after)) => Some(after),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn visible_after(&self, id: &OpId) -> bool {
+        match self {
+            Self::Current(Some(after)) => after.covers(id),
+            Self::Diff(_, after) => after.covers(id),
+            _ => true,
+        }
+    }
+
+    pub(crate) fn visible_before(&self, id: &OpId) -> bool {
+        self.predates(id)
+    }
+
+    pub(crate) fn predates(&self, id: &OpId) -> bool {
+        match self {
+            Self::Diff(before, _) => before.covers(id),
+            _ => false,
+        }
+    }
+}
+
+impl Clock {
+    pub(crate) fn isolate(&mut self, actor_index: usize) {
+        self.0[actor_index] = u32::MAX
+    }
+
+    pub(crate) fn covers(&self, id: &OpId) -> bool {
+        self.0[id.actor()] as u64 >= id.counter()
+    }
+}
+
+impl std::iter::FromIterator<Option<u32>> for Clock {
+    fn from_iter<I: IntoIterator<Item = Option<u32>>>(iter: I) -> Self {
+        Clock(iter.into_iter().map(|i| i.unwrap_or(0)).collect())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::cmp::Ordering;
+
+    impl Clock {
+        pub(crate) fn new(size: usize) -> Self {
+            Self(vec![0; size])
+        }
+
+        pub(crate) fn include(&mut self, actor_idx: usize, data: u32) -> bool {
+            if data > self.0[actor_idx] {
+                self.0[actor_idx] = data;
+                true
+            } else {
+                false
+            }
+        }
+
+        fn is_greater(&self, other: &Self) -> bool {
+            !std::iter::zip(self.0.iter(), other.0.iter()).any(|(a, b)| a < b)
+        }
+    }
+
+    impl PartialOrd for Clock {
+        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+            if self.0 == other.0 {
+                Some(Ordering::Equal)
+            } else if self.is_greater(other) {
+                Some(Ordering::Greater)
+            } else if other.is_greater(self) {
+                Some(Ordering::Less)
+            } else {
+                None
+            }
+        }
+    }
+
+    #[test]
+    fn covers() {
+        let mut clock = Clock::new(4);
+
+        clock.include(1, 20);
+        clock.include(2, 10);
+
+        assert!(clock.covers(&OpId::new(10, 1)));
+        assert!(clock.covers(&OpId::new(20, 1)));
+        assert!(!clock.covers(&OpId::new(30, 1)));
+
+        assert!(clock.covers(&OpId::new(5, 2)));
+        assert!(clock.covers(&OpId::new(10, 2)));
+        assert!(!clock.covers(&OpId::new(15, 2)));
+
+        assert!(!clock.covers(&OpId::new(1, 3)));
+        assert!(!clock.covers(&OpId::new(100, 3)));
+    }
+
+    #[test]
+    fn comparison() {
+        let mut base_clock = Clock::new(4);
+        base_clock.include(1, 1);
+        base_clock.include(2, 1);
+
+        let mut after_clock = base_clock.clone();
+        after_clock.include(1, 2);
+
+        assert!(after_clock > base_clock);
+        assert!(base_clock < after_clock);
+
+        assert!(base_clock == base_clock);
+
+        let mut new_actor_clock = base_clock.clone();
+        new_actor_clock.include(3, 1);
+
+        assert_eq!(
+            base_clock.partial_cmp(&new_actor_clock),
+            Some(Ordering::Less)
+        );
+        assert_eq!(
+            new_actor_clock.partial_cmp(&base_clock),
+            Some(Ordering::Greater)
+        );
+
+        assert_eq!(after_clock.partial_cmp(&new_actor_clock), None);
+        assert_eq!(new_actor_clock.partial_cmp(&after_clock), None);
+    }
+}

data/vendor/automerge-rust/automerge/src/columnar/column_range/boolean.rs

@@ -0,0 +1,83 @@
+use std::{borrow::Cow, ops::Range};
+
+use crate::columnar::encoding::{
+    BooleanDecoder, BooleanEncoder, MaybeBooleanDecoder, MaybeBooleanEncoder,
+};
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct BooleanRange(Range<usize>);
+
+impl BooleanRange {
+    pub(crate) fn decoder<'a>(&self, data: &'a [u8]) -> BooleanDecoder<'a> {
+        BooleanDecoder::from(Cow::Borrowed(&data[self.0.clone()]))
+    }
+
+    pub(crate) fn encode<I: Iterator<Item = bool>>(items: I, out: &mut Vec<u8>) -> Self {
+        let start = out.len();
+        let mut encoder = BooleanEncoder::from(out);
+        for i in items {
+            encoder.append(i);
+        }
+        let (_, len) = encoder.finish();
+        (start..(start + len)).into()
+    }
+}
+
+impl AsRef<Range<usize>> for BooleanRange {
+    fn as_ref(&self) -> &Range<usize> {
+        &self.0
+    }
+}
+
+impl From<Range<usize>> for BooleanRange {
+    fn from(r: Range<usize>) -> BooleanRange {
+        BooleanRange(r)
+    }
+}
+
+impl From<BooleanRange> for Range<usize> {
+    fn from(r: BooleanRange) -> Range<usize> {
+        r.0
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct MaybeBooleanRange(Range<usize>);
+
+impl MaybeBooleanRange {
+    pub(crate) fn decoder<'a>(&self, data: &'a [u8]) -> MaybeBooleanDecoder<'a> {
+        MaybeBooleanDecoder::from(Cow::Borrowed(&data[self.0.clone()]))
+    }
+
+    pub(crate) fn encode<I: Iterator<Item = bool>>(items: I, out: &mut Vec<u8>) -> Self {
+        let start = out.len();
+        let mut encoder = MaybeBooleanEncoder::from_sink(out);
+        for i in items {
+            encoder.append(i);
+        }
+        let (_, len) = encoder.finish();
+        (start..(start + len)).into()
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl AsRef<Range<usize>> for MaybeBooleanRange {
+    fn as_ref(&self) -> &Range<usize> {
+        &self.0
+    }
+}
+
+impl From<Range<usize>> for MaybeBooleanRange {
+    fn from(r: Range<usize>) -> MaybeBooleanRange {
+        MaybeBooleanRange(r)
+    }
+}
+
+impl From<MaybeBooleanRange> for Range<usize> {
+    fn from(r: MaybeBooleanRange) -> Range<usize> {
+        r.0
+    }
+}

data/vendor/automerge-rust/automerge/src/columnar/column_range/delta.rs

@@ -0,0 +1,148 @@
+use std::{borrow::Cow, convert::Infallible, ops::Range};
+
+use crate::columnar::{
+    encoding::{raw, DeltaDecoder, DeltaEncoder, Sink},
+    SpliceError,
+};
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct DeltaRange(Range<usize>);
+
+impl DeltaRange {
+    pub(crate) fn decoder<'a>(&self, data: &'a [u8]) -> DeltaDecoder<'a> {
+        DeltaDecoder::from(Cow::Borrowed(&data[self.0.clone()]))
+    }
+
+    pub(crate) fn encoder<S: Sink>(&self, output: S) -> DeltaEncoder<S> {
+        DeltaEncoder::from(output)
+    }
+
+    pub(crate) fn encode<I: Iterator<Item = Option<i64>>>(items: I, out: &mut Vec<u8>) -> Self {
+        // SAFETY: The incoming iterator is infallible and there are no existing items
+        Self::from(0..0)
+            .splice::<Infallible, _>(&[], 0..0, items.map(Ok), out)
+            .unwrap()
+    }
+
+    pub(crate) fn splice<E: std::error::Error, I: Iterator<Item = Result<Option<i64>, E>>>(
+        &self,
+        data: &[u8],
+        replace: Range<usize>,
+        mut replace_with: I,
+        out: &mut Vec<u8>,
+    ) -> Result<Self, SpliceError<raw::Error, E>> {
+        let start = out.len();
+        let mut decoder = self.decoder(data);
+        let mut encoder = self.encoder(out);
+        let mut idx = 0;
+        while idx < replace.start {
+            match decoder
+                .next()
+                .transpose()
+                .map_err(SpliceError::ReadExisting)?
+            {
+                Some(elem) => encoder.append(elem),
+                None => panic!("out of bounds"),
+            }
+            idx += 1;
+        }
+        for _ in 0..replace.len() {
+            decoder
+                .next()
+                .transpose()
+                .map_err(SpliceError::ReadExisting)?;
+            if let Some(next) = replace_with
+                .next()
+                .transpose()
+                .map_err(SpliceError::ReadReplace)?
+            {
+                encoder.append(next);
+            }
+        }
+        for next in replace_with {
+            let next = next.map_err(SpliceError::ReadReplace)?;
+            encoder.append(next);
+        }
+        for next in decoder {
+            let next = next.map_err(SpliceError::ReadExisting)?;
+            encoder.append(next);
+        }
+        let (_, len) = encoder.finish();
+        Ok((start..(start + len)).into())
+    }
+}
+
+impl AsRef<Range<usize>> for DeltaRange {
+    fn as_ref(&self) -> &Range<usize> {
+        &self.0
+    }
+}
+
+impl From<Range<usize>> for DeltaRange {
+    fn from(r: Range<usize>) -> DeltaRange {
+        DeltaRange(r)
+    }
+}
+
+impl From<DeltaRange> for Range<usize> {
+    fn from(r: DeltaRange) -> Range<usize> {
+        r.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::columnar::encoding::properties::option_splice_scenario;
+    use proptest::prelude::*;
+
+    fn encode<I: Iterator<Item = Option<i64>>>(vals: I) -> (DeltaRange, Vec<u8>) {
+        let mut buf = Vec::<u8>::new();
+        let range = DeltaRange::encode(vals, &mut buf);
+        (range, buf)
+    }
+
+    fn decode(range: DeltaRange, buf: &[u8]) -> Vec<Option<i64>> {
+        range.decoder(buf).collect::<Result<Vec<_>, _>>().unwrap()
+    }
+
+    fn encodable_int() -> impl Strategy<Value = i64> + Clone {
+        0..(i64::MAX / 2)
+    }
+
+    proptest! {
+        #[test]
+        fn encode_decode_delta(vals in proptest::collection::vec(proptest::option::of(encodable_int()), 0..100)) {
+            let (r, encoded) = encode(vals.iter().copied());
+            if vals.iter().all(|v| v.is_none()) {
+                assert_eq!(encoded.len(), 0);
+                let decoded = decode(r, &encoded);
+                assert_eq!(Vec::<Option<i64>>::new(), decoded)
+            } else {
+                let decoded = decode(r, &encoded);
+                assert_eq!(vals, decoded)
+            }
+        }
+
+        #[test]
+        fn splice_delta(scenario in option_splice_scenario(proptest::option::of(encodable_int()))) {
+            let (range, encoded) = encode(scenario.initial_values.iter().copied());
+            let mut out = Vec::new();
+            let replacements: Vec<Result<Option<i64>, Infallible>> = scenario.replacements.iter().cloned().map(Ok).collect();
+            let new_range = range.splice(&encoded, scenario.replace_range.clone(), replacements.into_iter(), &mut out).unwrap();
+            let decoded = decode(new_range, &out);
+            scenario.check_optional(decoded);
+        }
+    }
+
+    #[test]
+    fn bugbug() {
+        let vals: Vec<i64> = vec![6, 5, 8, 9, 10, 11, 12, 13];
+        let (r, encoded) = encode(vals.iter().copied().map(Some));
+        let decoded = decode(r, &encoded)
+            .into_iter()
+            .map(Option::unwrap)
+            .collect::<Vec<_>>();
+        assert_eq!(decoded, vals);
+    }
+}

data/vendor/automerge-rust/automerge/src/columnar/column_range/generic/group.rs

@@ -0,0 +1,138 @@
+use std::ops::Range;
+
+use super::{CellValue, SimpleColIter, SimpleColRange, SimpleValue};
+use crate::columnar::{
+    column_range::{RleRange, ValueIter, ValueRange},
+    encoding::{col_error::DecodeColumnError, RleDecoder},
+};
+
+/// A group column range is one with a "num" column and zero or more "grouped" columns. The "num"
+/// column contains RLE encoded u64s, each `u64` represents the number of values to read from each
+/// of the grouped columns in order to produce a `CellValue::Group` for the current row.
+#[derive(Debug, Clone)]
+pub(crate) struct GroupRange {
+    pub(crate) num: RleRange<u64>,
+    pub(crate) values: Vec<GroupedColumnRange>,
+}
+
+impl GroupRange {
+    pub(crate) fn new(num: RleRange<u64>, values: Vec<GroupedColumnRange>) -> Self {
+        Self { num, values }
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn iter<'a>(&self, data: &'a [u8]) -> GroupIter<'a> {
+        GroupIter {
+            num: self.num.decoder(data),
+            values: self.values.iter().map(|v| v.iter(data)).collect(),
+        }
+    }
+
+    pub(crate) fn range(&self) -> Range<usize> {
+        let start = self.num.start();
+        let end = self
+            .values
+            .last()
+            .map(|v| v.range().end)
+            .unwrap_or_else(|| self.num.end());
+        start..end
+    }
+}
+
+/// The type of ranges which can be the "grouped" columns in a `GroupRange`
+#[derive(Debug, Clone)]
+pub(crate) enum GroupedColumnRange {
+    Value(ValueRange),
+    Simple(SimpleColRange),
+}
+
+impl GroupedColumnRange {
+    fn iter<'a>(&self, data: &'a [u8]) -> GroupedColIter<'a> {
+        match self {
+            Self::Value(vr) => GroupedColIter::Value(vr.iter(data)),
+            Self::Simple(sc) => GroupedColIter::Simple(sc.iter(data)),
+        }
+    }
+
+    pub(crate) fn range(&self) -> Range<usize> {
+        match self {
+            Self::Value(vr) => vr.range(),
+            Self::Simple(s) => s.range(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct GroupIter<'a> {
+    num: RleDecoder<'a, u64>,
+    values: Vec<GroupedColIter<'a>>,
+}
+
+impl GroupIter<'_> {
+    fn try_next(&mut self) -> Result<Option<CellValue>, DecodeColumnError> {
+        let num = self
+            .num
+            .next()
+            .transpose()
+            .map_err(|e| DecodeColumnError::decode_raw("num", e))?;
+        match num {
+            None => Ok(None),
+            Some(None) => Err(DecodeColumnError::unexpected_null("num")),
+            Some(Some(num)) => {
+                let mut row = Vec::new();
+                for _ in 0..num {
+                    let mut inner_row = Vec::new();
+                    for (index, value_col) in self.values.iter_mut().enumerate() {
+                        match value_col.next().transpose()? {
+                            None => {
+                                return Err(DecodeColumnError::unexpected_null(format!(
+                                    "col {}",
+                                    index
+                                )))
+                            }
+                            Some(v) => {
+                                inner_row.push(v);
+                            }
+                        }
+                    }
+                    row.push(inner_row);
+                }
+                Ok(Some(CellValue::Group(row)))
+            }
+        }
+    }
+}
+
+impl Iterator for GroupIter<'_> {
+    type Item = Result<CellValue, DecodeColumnError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.try_next().transpose()
+    }
+}
+
+#[derive(Debug, Clone)]
+enum GroupedColIter<'a> {
+    Value(ValueIter<'a>),
+    Simple(SimpleColIter<'a>),
+}
+
+impl GroupedColIter<'_> {
+    fn try_next(&mut self) -> Result<Option<SimpleValue>, DecodeColumnError> {
+        match self {
+            Self::Value(viter) => Ok(viter.next().transpose()?.map(SimpleValue::Value)),
+            Self::Simple(siter) => siter
+                .next()
+                .transpose()
+                .map_err(|e| DecodeColumnError::decode_raw("a simple column", e)),
+        }
+    }
+}
+
+impl Iterator for GroupedColIter<'_> {
+    type Item = Result<SimpleValue, DecodeColumnError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.try_next().transpose()
+    }
+}

data/vendor/automerge-rust/automerge/src/columnar/column_range/generic/simple.rs

@@ -0,0 +1,76 @@
+use std::ops::Range;
+
+use crate::columnar::{
+    column_range::{BooleanRange, DeltaRange, RleRange},
+    encoding::{raw, BooleanDecoder, DeltaDecoder, RleDecoder},
+};
+
+use super::SimpleValue;
+
+/// The four types of "simple" column defined in the raw format
+#[derive(Debug, Clone)]
+pub(crate) enum SimpleColRange {
+    /// A column containing RLE encoded u64's
+    RleInt(RleRange<u64>),
+    /// A column containing RLE encoded strings
+    RleString(RleRange<smol_str::SmolStr>),
+    /// A column containing delta -> RLE encoded i64s
+    Delta(DeltaRange),
+    /// A column containing boolean values
+    Boolean(BooleanRange),
+}
+
+impl SimpleColRange {
+    pub(super) fn iter<'a>(&self, data: &'a [u8]) -> SimpleColIter<'a> {
+        match self {
+            Self::RleInt(r) => SimpleColIter::RleInt(r.decoder(data)),
+            Self::RleString(r) => SimpleColIter::RleString(r.decoder(data)),
+            Self::Delta(r) => SimpleColIter::Delta(r.decoder(data)),
+            Self::Boolean(r) => SimpleColIter::Boolean(r.decoder(data)),
+        }
+    }
+
+    pub(crate) fn range(&self) -> Range<usize> {
+        match self {
+            Self::RleInt(r) => r.clone().into(),
+            Self::RleString(r) => r.clone().into(),
+            Self::Delta(r) => r.clone().into(),
+            Self::Boolean(r) => r.clone().into(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum SimpleColIter<'a> {
+    RleInt(RleDecoder<'a, u64>),
+    RleString(RleDecoder<'a, smol_str::SmolStr>),
+    Delta(DeltaDecoder<'a>),
+    Boolean(BooleanDecoder<'a>),
+}
+
+impl SimpleColIter<'_> {
+    fn try_next(&mut self) -> Result<Option<SimpleValue>, raw::Error> {
+        match self {
+            Self::RleInt(d) => read_col(d, SimpleValue::Uint),
+            Self::RleString(d) => read_col(d, SimpleValue::String),
+            Self::Delta(d) => read_col(d, SimpleValue::Int),
+            Self::Boolean(d) => Ok(d.next().transpose()?.map(SimpleValue::Bool)),
+        }
+    }
+}
+
+fn read_col<C, T, F, U>(mut col: C, f: F) -> Result<Option<U>, raw::Error>
+where
+    C: Iterator<Item = Result<Option<T>, raw::Error>>,
+    F: Fn(Option<T>) -> U,
+{
+    col.next().transpose().map(|v| v.map(f))
+}
+
+impl Iterator for SimpleColIter<'_> {
+    type Item = Result<SimpleValue, raw::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.try_next().transpose()
+    }
+}