automerge-rb 0.1.1

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

@@ -0,0 +1,197 @@
+use std::borrow::Cow;
+
+use super::{raw, Encodable, RawDecoder, Sink};
+
+/// Encodes booleans by storing the count of the same value.
+///
+/// The sequence of numbers describes the count of false values on even indices (0-indexed) and the
+/// count of true values on odd indices (0-indexed).
+///
+/// Counts are encoded as usize.
+pub(crate) struct BooleanEncoder<S> {
+    written: usize,
+    //buf: &'a mut Vec<u8>,
+    buf: S,
+    last: bool,
+    count: usize,
+}
+
+impl BooleanEncoder<Vec<u8>> {
+    pub(crate) fn new() -> BooleanEncoder<Vec<u8>> {
+        BooleanEncoder::from_sink(Vec::new())
+    }
+}
+
+impl<S: Sink> BooleanEncoder<S> {
+    pub(crate) fn from_sink(sink: S) -> Self {
+        BooleanEncoder {
+            written: 0,
+            buf: sink,
+            last: false,
+            count: 0,
+        }
+    }
+
+    pub(crate) fn append(&mut self, value: bool) {
+        if value == self.last {
+            self.count += 1;
+        } else {
+            self.written += self.count.encode(&mut self.buf);
+            self.last = value;
+            self.count = 1;
+        }
+    }
+
+    pub(crate) fn finish(mut self) -> (S, usize) {
+        if self.count > 0 {
+            self.written += self.count.encode(&mut self.buf);
+        }
+        (self.buf, self.written)
+    }
+}
+
+impl<S: Sink> From<S> for BooleanEncoder<S> {
+    fn from(output: S) -> Self {
+        BooleanEncoder::from_sink(output)
+    }
+}
+
+/// See the discussion of [`BooleanEncoder`] for details on this encoding
+#[derive(Clone, Debug)]
+pub(crate) struct BooleanDecoder<'a> {
+    decoder: RawDecoder<'a>,
+    last_value: bool,
+    count: usize,
+}
+
+impl<'a> From<Cow<'a, [u8]>> for BooleanDecoder<'a> {
+    fn from(bytes: Cow<'a, [u8]>) -> Self {
+        BooleanDecoder {
+            decoder: RawDecoder::from(bytes),
+            last_value: true,
+            count: 0,
+        }
+    }
+}
+
+impl<'a> From<&'a [u8]> for BooleanDecoder<'a> {
+    fn from(d: &'a [u8]) -> Self {
+        Cow::Borrowed(d).into()
+    }
+}
+
+// this is an endless iterator that returns false after input is exhausted
+impl Iterator for BooleanDecoder<'_> {
+    type Item = Result<bool, raw::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.count == 0 {
+            if self.decoder.done() && self.count == 0 {
+                return None;
+            }
+            self.count = match self.decoder.read() {
+                Ok(c) => c,
+                Err(e) => return Some(Err(e)),
+            };
+            self.last_value = !self.last_value;
+        }
+        self.count -= 1;
+        Some(Ok(self.last_value))
+    }
+}
+
+/// Like a `BooleanEncoder` but if all the values in the column are `false` then will return an
+/// empty range rather than a range with `count` false values.
+pub(crate) struct MaybeBooleanEncoder<S> {
+    encoder: BooleanEncoder<S>,
+    all_false: bool,
+}
+
+impl MaybeBooleanEncoder<Vec<u8>> {
+    pub(crate) fn new() -> MaybeBooleanEncoder<Vec<u8>> {
+        MaybeBooleanEncoder::from_sink(Vec::new())
+    }
+}
+
+impl<S: Sink> MaybeBooleanEncoder<S> {
+    pub(crate) fn from_sink(buf: S) -> MaybeBooleanEncoder<S> {
+        MaybeBooleanEncoder {
+            encoder: BooleanEncoder::from_sink(buf),
+            all_false: true,
+        }
+    }
+
+    pub(crate) fn append(&mut self, value: bool) {
+        if value {
+            self.all_false = false;
+        }
+        self.encoder.append(value);
+    }
+
+    pub(crate) fn finish(self) -> (S, usize) {
+        if self.all_false {
+            (self.encoder.buf, 0)
+        } else {
+            self.encoder.finish()
+        }
+    }
+}
+
+/// Like a `BooleanDecoder` but if the underlying range is empty then just returns an infinite
+/// sequence of `None`
+#[derive(Clone, Debug)]
+pub(crate) struct MaybeBooleanDecoder<'a>(BooleanDecoder<'a>);
+
+impl<'a> From<Cow<'a, [u8]>> for MaybeBooleanDecoder<'a> {
+    fn from(bytes: Cow<'a, [u8]>) -> Self {
+        MaybeBooleanDecoder(BooleanDecoder::from(bytes))
+    }
+}
+
+impl<'a> From<&'a [u8]> for MaybeBooleanDecoder<'a> {
+    fn from(d: &'a [u8]) -> Self {
+        Cow::Borrowed(d).into()
+    }
+}
+
+impl Iterator for MaybeBooleanDecoder<'_> {
+    type Item = Result<Option<bool>, raw::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.0.decoder.is_empty() {
+            None
+        } else {
+            self.0.next().transpose().map(Some).transpose()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use proptest::prelude::*;
+
+    fn encode(vals: &[bool]) -> Vec<u8> {
+        let mut buf = Vec::new();
+        let mut encoder = BooleanEncoder::from_sink(&mut buf);
+        for val in vals {
+            encoder.append(*val);
+        }
+        encoder.finish();
+        buf
+    }
+
+    fn decode(buf: &[u8]) -> Vec<bool> {
+        BooleanDecoder::from(buf)
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap()
+    }
+
+    proptest! {
+        #[test]
+        fn encode_decode_bools(vals in proptest::collection::vec(any::<bool>(), 0..100)) {
+            assert_eq!(vals, decode(&encode(&vals)))
+        }
+    }
+}

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

@@ -0,0 +1,88 @@
+#[derive(Clone, Debug)]
+pub struct DecodeColumnError {
+    path: Path,
+    error: DecodeColErrorKind,
+}
+
+impl std::error::Error for DecodeColumnError {}
+
+impl std::fmt::Display for DecodeColumnError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.error {
+            DecodeColErrorKind::UnexpectedNull => {
+                write!(f, "unexpected null in column {}", self.path)
+            }
+            DecodeColErrorKind::InvalidValue { reason } => {
+                write!(f, "invalid value in column {}: {}", self.path, reason)
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+struct Path(Vec<String>);
+
+impl std::fmt::Display for Path {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for (index, elem) in self.0.iter().rev().enumerate() {
+            if index != 0 {
+                write!(f, ":")?;
+            }
+            write!(f, "{}", elem)?;
+        }
+        Ok(())
+    }
+}
+
+impl Path {
+    fn push<S: AsRef<str>>(&mut self, col: S) {
+        self.0.push(col.as_ref().to_string())
+    }
+}
+
+impl<S: AsRef<str>> From<S> for Path {
+    fn from(p: S) -> Self {
+        Self(vec![p.as_ref().to_string()])
+    }
+}
+
+#[derive(Clone, Debug)]
+enum DecodeColErrorKind {
+    UnexpectedNull,
+    InvalidValue { reason: String },
+}
+
+impl DecodeColumnError {
+    pub(crate) fn decode_raw<S: AsRef<str>>(col: S, raw_err: super::raw::Error) -> Self {
+        Self {
+            path: col.into(),
+            error: DecodeColErrorKind::InvalidValue {
+                reason: raw_err.to_string(),
+            },
+        }
+    }
+
+    pub(crate) fn unexpected_null<S: AsRef<str>>(col: S) -> DecodeColumnError {
+        Self {
+            path: col.into(),
+            error: DecodeColErrorKind::UnexpectedNull,
+        }
+    }
+
+    pub(crate) fn invalid_value<S: AsRef<str>, R: AsRef<str>>(
+        col: S,
+        reason: R,
+    ) -> DecodeColumnError {
+        Self {
+            path: col.into(),
+            error: DecodeColErrorKind::InvalidValue {
+                reason: reason.as_ref().to_string(),
+            },
+        }
+    }
+
+    pub(crate) fn in_column<S: AsRef<str>>(mut self, col: S) -> DecodeColumnError {
+        self.path.push(col.as_ref());
+        self
+    }
+}

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

@@ -0,0 +1,133 @@
+use crate::{
+    columnar::{
+        column_range::{KeyIter, ObjIdIter, OpIdListIter, ValueIter},
+        encoding, Key,
+    },
+    types::{ObjId, OpId},
+    ScalarValue,
+};
+
+pub(crate) trait IntoColError: std::error::Error {
+    fn into_col_error<S: AsRef<str>>(self, col_name: S) -> encoding::DecodeColumnError;
+}
+
+impl IntoColError for encoding::raw::Error {
+    fn into_col_error<S: AsRef<str>>(self, col_name: S) -> encoding::DecodeColumnError {
+        encoding::DecodeColumnError::decode_raw(col_name, self)
+    }
+}
+
+impl IntoColError for encoding::DecodeColumnError {
+    fn into_col_error<S: AsRef<str>>(self, col_name: S) -> encoding::DecodeColumnError {
+        self.in_column(col_name)
+    }
+}
+
+/// A helper trait which allows users to annotate decoders with errors containing a column name
+///
+/// Frequently we have an iterator which decodes values from some underlying column storage, e.g.
+/// we might have a `BooleanDecoder` which decodes items from an `insert` column. In the context
+/// where we are reading from this column we would like to produce errors which describe which
+/// column the error occurred in - to this end we require that the error produced by the underlying
+/// decoder implement `IntoColError` and we provide the `next_in_col` method to call
+/// `into_col_error` on any errors produced by the decoder.
+pub(crate) trait ColumnDecoder<T>: Iterator<Item = Result<T, Self::Error>> {
+    type Error: IntoColError;
+    type Value;
+
+    fn maybe_next_in_col<S: AsRef<str>>(
+        &mut self,
+        col_name: S,
+    ) -> Result<Option<Self::Value>, encoding::DecodeColumnError>;
+
+    /// Decode the next value from this decoder, annotating any error with the `col_name`
+    fn next_in_col<S: AsRef<str>>(
+        &mut self,
+        col_name: S,
+    ) -> Result<Self::Value, encoding::DecodeColumnError> {
+        self.maybe_next_in_col(&col_name)?
+            .ok_or_else(|| encoding::DecodeColumnError::unexpected_null(col_name))
+    }
+}
+
+impl ColumnDecoder<bool> for encoding::BooleanDecoder<'_> {
+    type Error = encoding::raw::Error;
+    type Value = bool;
+
+    fn maybe_next_in_col<S: AsRef<str>>(
+        &mut self,
+        col_name: S,
+    ) -> Result<Option<bool>, encoding::DecodeColumnError> {
+        self.next()
+            .transpose()
+            .map_err(|e| e.into_col_error(col_name))
+    }
+}
+
+impl<I, T, E> ColumnDecoder<Option<T>> for I
+where
+    I: Iterator<Item = Result<Option<T>, E>>,
+    E: IntoColError,
+{
+    type Error = E;
+    type Value = T;
+
+    fn maybe_next_in_col<S: AsRef<str>>(
+        &mut self,
+        col_name: S,
+    ) -> Result<Option<T>, encoding::DecodeColumnError> {
+        Ok(self
+            .next()
+            .transpose()
+            .map_err(|e| e.into_col_error(col_name))?
+            .flatten())
+    }
+}
+
+impl ColumnDecoder<Vec<OpId>> for OpIdListIter<'_> {
+    type Error = encoding::DecodeColumnError;
+    type Value = Vec<OpId>;
+
+    fn maybe_next_in_col<S: AsRef<str>>(
+        &mut self,
+        col_name: S,
+    ) -> Result<Option<Vec<OpId>>, encoding::DecodeColumnError> {
+        self.next().transpose().map_err(|e| e.in_column(col_name))
+    }
+}
+
+impl ColumnDecoder<ScalarValue> for ValueIter<'_> {
+    type Error = encoding::DecodeColumnError;
+    type Value = ScalarValue;
+
+    fn maybe_next_in_col<S: AsRef<str>>(
+        &mut self,
+        col_name: S,
+    ) -> Result<Option<Self::Value>, encoding::DecodeColumnError> {
+        self.next().transpose().map_err(|e| e.in_column(col_name))
+    }
+}
+
+impl ColumnDecoder<Key> for KeyIter<'_> {
+    type Error = encoding::DecodeColumnError;
+    type Value = Key;
+
+    fn maybe_next_in_col<S: AsRef<str>>(
+        &mut self,
+        col_name: S,
+    ) -> Result<Option<Self::Value>, encoding::DecodeColumnError> {
+        self.next().transpose().map_err(|e| e.in_column(col_name))
+    }
+}
+
+impl ColumnDecoder<ObjId> for ObjIdIter<'_> {
+    type Value = ObjId;
+    type Error = encoding::DecodeColumnError;
+
+    fn maybe_next_in_col<S: AsRef<str>>(
+        &mut self,
+        col_name: S,
+    ) -> Result<Option<Self::Value>, encoding::DecodeColumnError> {
+        self.next().transpose().map_err(|e| e.in_column(col_name))
+    }
+}

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

@@ -0,0 +1,175 @@
+use smol_str::SmolStr;
+use std::{borrow::Cow, convert::TryFrom, io::Read, str};
+
+use super::{Decodable, DecodeError};
+use crate::ActorId;
+
+// We don't allow decoding items which are larger than this. Almost nothing should be this large
+// so this is really guarding against bad encodings which accidentally grab loads of memory
+const MAX_ALLOCATION: usize = 1000000000;
+
+impl Decodable for u8 {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        let mut buffer = [0; 1];
+        bytes.read_exact(&mut buffer)?;
+        Ok(buffer[0])
+    }
+}
+
+impl Decodable for u32 {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        u64::decode::<R>(bytes).and_then(|val| Self::try_from(val).map_err(DecodeError::from))
+    }
+}
+
+impl Decodable for usize {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        u64::decode::<R>(bytes).and_then(|val| Self::try_from(val).map_err(DecodeError::from))
+    }
+}
+
+impl Decodable for isize {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        i64::decode::<R>(bytes).and_then(|val| Self::try_from(val).map_err(DecodeError::from))
+    }
+}
+
+impl Decodable for i32 {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        i64::decode::<R>(bytes).and_then(|val| Self::try_from(val).map_err(DecodeError::from))
+    }
+}
+
+impl Decodable for i64 {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        leb128::read::signed(bytes).map_err(DecodeError::from)
+    }
+}
+
+impl Decodable for f64 {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        let mut buffer = [0; 8];
+        bytes.read_exact(&mut buffer)?;
+        Ok(Self::from_le_bytes(buffer))
+    }
+}
+
+impl Decodable for f32 {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        let mut buffer = [0; 4];
+        bytes.read_exact(&mut buffer)?;
+        Ok(Self::from_le_bytes(buffer))
+    }
+}
+
+impl Decodable for u64 {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        leb128::read::unsigned(bytes).map_err(DecodeError::from)
+    }
+}
+
+impl Decodable for Vec<u8> {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        let len = usize::decode::<R>(bytes)?;
+        if len == 0 {
+            return Ok(vec![]);
+        }
+        if len > MAX_ALLOCATION {
+            return Err(DecodeError::OverlargeAllocation {
+                attempted: len,
+                maximum: MAX_ALLOCATION,
+            });
+        }
+        let mut buffer = vec![0; len];
+        bytes.read_exact(buffer.as_mut_slice())?;
+        Ok(buffer)
+    }
+}
+
+impl Decodable for SmolStr {
+    fn decode<R>(bytes: &mut R) -> Result<SmolStr, DecodeError>
+    where
+        R: Read,
+    {
+        let buffer = Vec::decode(bytes)?;
+        str::from_utf8(&buffer)
+            .map(|t| t.into())
+            .map_err(|_| DecodeError::BadString)
+    }
+}
+
+impl Decodable for Cow<'static, SmolStr> {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: std::io::Read,
+    {
+        SmolStr::decode(bytes).map(Cow::Owned)
+    }
+}
+
+impl Decodable for String {
+    fn decode<R>(bytes: &mut R) -> Result<String, DecodeError>
+    where
+        R: Read,
+    {
+        let buffer = Vec::decode(bytes)?;
+        str::from_utf8(&buffer)
+            .map(|t| t.into())
+            .map_err(|_| DecodeError::BadString)
+    }
+}
+
+impl Decodable for Option<String> {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        let buffer = Vec::decode(bytes)?;
+        if buffer.is_empty() {
+            return Ok(None);
+        }
+        str::from_utf8(&buffer)
+            .map(|t| Some(t.into()))
+            .map_err(|_| DecodeError::BadString)
+    }
+}
+
+impl Decodable for ActorId {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: Read,
+    {
+        let buffer = Vec::decode(bytes)?;
+        Ok(buffer.into())
+    }
+}

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

@@ -0,0 +1,96 @@
+use std::borrow::Cow;
+
+use super::{raw, RleDecoder, RleEncoder, Sink};
+
+/// Encodes integers as the change since the previous value.
+///
+/// The initial value is 0 encoded as u64. Deltas are encoded as i64.
+///
+/// Run length encoding is then applied to the resulting sequence.
+pub(crate) struct DeltaEncoder<S> {
+    rle: RleEncoder<S, i64>,
+    absolute_value: i64,
+}
+
+impl<S: Sink> DeltaEncoder<S> {
+    pub(crate) fn new(output: S) -> DeltaEncoder<S> {
+        DeltaEncoder {
+            rle: RleEncoder::new(output),
+            absolute_value: 0,
+        }
+    }
+
+    pub(crate) fn append_value(&mut self, value: i64) {
+        self.rle
+            .append_value(value.saturating_sub(self.absolute_value));
+        self.absolute_value = value;
+    }
+
+    pub(crate) fn append_null(&mut self) {
+        self.rle.append_null();
+    }
+
+    pub(crate) fn append(&mut self, val: Option<i64>) {
+        match val {
+            Some(v) => self.append_value(v),
+            None => self.append_null(),
+        }
+    }
+
+    pub(crate) fn finish(self) -> (S, usize) {
+        self.rle.finish()
+    }
+}
+
+impl<S: Sink> From<S> for DeltaEncoder<S> {
+    fn from(output: S) -> Self {
+        DeltaEncoder::new(output)
+    }
+}
+
+/// See discussion on [`DeltaEncoder`] for the format data is stored in.
+#[derive(Debug, Clone)]
+pub(crate) struct DeltaDecoder<'a> {
+    rle: RleDecoder<'a, i64>,
+    absolute_val: i64,
+}
+
+impl DeltaDecoder<'_> {
+    #[allow(unused)]
+    pub(crate) fn done(&self) -> bool {
+        self.rle.done()
+    }
+}
+
+impl<'a> From<Cow<'a, [u8]>> for DeltaDecoder<'a> {
+    fn from(bytes: Cow<'a, [u8]>) -> Self {
+        DeltaDecoder {
+            rle: RleDecoder::from(bytes),
+            absolute_val: 0,
+        }
+    }
+}
+
+impl<'a> From<&'a [u8]> for DeltaDecoder<'a> {
+    fn from(d: &'a [u8]) -> Self {
+        Cow::Borrowed(d).into()
+    }
+}
+
+impl Iterator for DeltaDecoder<'_> {
+    type Item = Result<Option<i64>, raw::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.rle.next() {
+            Some(Ok(next)) => match next {
+                Some(delta) => {
+                    self.absolute_val = self.absolute_val.saturating_add(delta);
+                    Some(Ok(Some(self.absolute_val)))
+                }
+                None => Some(Ok(None)),
+            },
+            Some(Err(e)) => Some(Err(e)),
+            None => None,
+        }
+    }
+}