automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/src/storage/bundle/error.rs

@@ -0,0 +1,42 @@
+use crate::op_set2::ReadOpError;
+use crate::storage::columns::raw_column;
+use crate::storage::{chunk, parse};
+
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum ParseError {
+    #[error("invalid end of input")]
+    Needed,
+    #[error("compression error in change columns")]
+    CompressedChangeCols,
+    #[error("compression error in op columns")]
+    CompressedOpCols,
+    #[error("invalid change cols: {0}")]
+    InvalidColumns(Box<dyn std::error::Error + Send + Sync + 'static>),
+    #[error("failed to parse header: {0}")]
+    Header(#[from] chunk::error::Header),
+    #[error("invalid change column")]
+    InvalidChangeColumn(u32),
+    #[error("invalid op column")]
+    InvalidOpColumn(u32),
+    #[error(transparent)]
+    ParseColumns(#[from] raw_column::ParseError),
+    #[error(transparent)]
+    Leb128(#[from] parse::leb128::Error),
+    #[error(transparent)]
+    ReadOp(#[from] ReadOpError),
+    #[error(transparent)]
+    Pack(#[from] hexane::PackError),
+    #[error(transparent)]
+    Deflate(#[from] std::io::Error),
+    #[error("failed to unbundle: {0}")]
+    Unbundle(Box<dyn std::error::Error + Send + Sync + 'static>),
+}
+
+impl<E: Into<ParseError>> From<parse::ParseError<E>> for ParseError {
+    fn from(e: parse::ParseError<E>) -> ParseError {
+        match e {
+            parse::ParseError::Error(e) => e.into(),
+            parse::ParseError::Incomplete(_) => ParseError::Needed,
+        }
+    }
+}

data/vendor/automerge-rust/automerge/src/storage/bundle/meta.rs

@@ -0,0 +1,23 @@
+use std::borrow::Cow;
+
+use crate::types::ChangeHash;
+
+#[derive(Clone, Debug)]
+pub(crate) struct BundleMetadata<'a> {
+    pub(crate) hash: ChangeHash,
+    pub(crate) actor: usize,
+    pub(crate) seq: u64,
+    pub(crate) max_op: u64,
+    pub(crate) timestamp: i64,
+    pub(crate) message: Option<Cow<'a, str>>,
+    pub(crate) deps: Vec<ChangeHash>,
+    pub(crate) extra: Cow<'a, [u8]>,
+    pub(crate) start_op: u64,
+    pub(crate) builder: usize,
+}
+
+impl BundleMetadata<'_> {
+    pub(crate) fn num_ops(&self) -> usize {
+        (1 + self.max_op - self.start_op) as usize
+    }
+}

data/vendor/automerge-rust/automerge/src/storage/bundle/storage.rs

@@ -0,0 +1,146 @@
+use std::borrow::Cow;
+use std::marker::PhantomData;
+use std::ops::Range;
+
+use crate::op_set2::change::ChangeCollector;
+use crate::storage::change::{OpReadState, Unverified, Verified};
+use crate::storage::columns::compression;
+use crate::storage::{parse, Header, RawColumns};
+use crate::types::{ActorId, ChangeHash};
+use crate::Change;
+
+use super::{BundleChangeIter, BundleChangeIterUnverified, OpIter, OpIterUnverified, ParseError};
+
+#[derive(Clone, Debug)]
+pub(crate) struct BundleStorage<'a, OpReadState> {
+    pub(crate) bytes: Cow<'a, [u8]>,
+    pub(crate) header: Header,
+    pub(crate) deps: Vec<ChangeHash>,
+    pub(crate) actors: Vec<ActorId>,
+    pub(crate) ops_meta: RawColumns<compression::Uncompressed>,
+    pub(crate) ops_data: Range<usize>,
+    pub(crate) changes_meta: RawColumns<compression::Uncompressed>,
+    pub(crate) changes_data: Range<usize>,
+    pub(crate) _phantom: PhantomData<OpReadState>,
+}
+
+impl<O: OpReadState> BundleStorage<'_, O> {
+    pub(crate) fn into_owned(self) -> BundleStorage<'static, O> {
+        BundleStorage {
+            bytes: Cow::Owned(self.bytes.into_owned()),
+            header: self.header,
+            deps: self.deps,
+            actors: self.actors,
+            ops_meta: self.ops_meta,
+            ops_data: self.ops_data,
+            changes_meta: self.changes_meta,
+            changes_data: self.changes_data,
+            _phantom: self._phantom,
+        }
+    }
+
+    pub(crate) fn checksum_valid(&self) -> bool {
+        self.header.checksum_valid()
+    }
+}
+
+impl<'a> BundleStorage<'a, Unverified> {
+    pub(crate) fn parse_following_header(
+        input: parse::Input<'a>,
+        header: Header,
+    ) -> parse::ParseResult<'a, BundleStorage<'a, Unverified>, ParseError> {
+        let (i, deps) = parse::length_prefixed(parse::change_hash)(input)?;
+        let (i, actors) = parse::length_prefixed(parse::actor_id)(i)?;
+
+        let (i, changes_meta) = RawColumns::parse(i)?;
+        let (i, changes) =
+            parse::range_of(|i| parse::take_n(changes_meta.total_column_len(), i), i)?;
+        let changes_meta = changes_meta
+            .uncompressed()
+            .ok_or(parse::ParseError::Error(ParseError::CompressedChangeCols))?;
+        // this validates that the iterator can be created
+        BundleChangeIterUnverified::try_new(&changes_meta, changes.value)
+            .map_err(|e| parse::ParseError::Error(ParseError::InvalidColumns(Box::new(e))))?;
+
+        let (i, ops_meta) = RawColumns::parse(i)?;
+        let ops_meta = ops_meta
+            .uncompressed()
+            .ok_or(parse::ParseError::Error(ParseError::CompressedOpCols))?;
+        let (_, ops) = parse::range_of(|i| parse::take_n(ops_meta.total_column_len(), i), i)?;
+        OpIterUnverified::try_new(&ops_meta, ops.value)
+            .map_err(|e| parse::ParseError::Error(ParseError::InvalidColumns(Box::new(e))))?;
+
+        Ok((
+            parse::Input::empty(),
+            BundleStorage {
+                bytes: input.bytes().into(),
+                header,
+                deps,
+                actors,
+                ops_meta,
+                ops_data: ops.range,
+                changes_meta,
+                changes_data: changes.range,
+                _phantom: PhantomData,
+            },
+        ))
+    }
+
+    pub(crate) fn verify(self) -> Result<BundleStorage<'a, Verified>, ParseError> {
+        for c in self.iter_change_meta() {
+            let _ = c?;
+        }
+        for o in self.iter_ops() {
+            let _ = o?;
+        }
+        Ok(BundleStorage {
+            bytes: self.bytes,
+            header: self.header,
+            deps: self.deps,
+            actors: self.actors,
+            ops_meta: self.ops_meta,
+            ops_data: self.ops_data,
+            changes_meta: self.changes_meta,
+            changes_data: self.changes_data,
+            _phantom: PhantomData,
+        })
+    }
+
+    pub(crate) fn iter_ops(&self) -> OpIterUnverified<'_> {
+        let bytes = &self.bytes[self.ops_data.clone()];
+        OpIterUnverified::new(&self.ops_meta, bytes)
+    }
+
+    fn iter_change_meta(&self) -> BundleChangeIterUnverified<'_> {
+        let change_data = &self.bytes[self.changes_data.clone()];
+        BundleChangeIterUnverified::new(&self.changes_meta, change_data)
+    }
+}
+
+impl BundleStorage<'_, Verified> {
+    pub(crate) fn to_changes(&self) -> Result<Vec<Change>, ParseError> {
+        let change_meta = self.iter_change_meta().collect();
+        let mut collector = ChangeCollector::from_bundle_changes(change_meta, &self.actors);
+        for op in self.iter_ops() {
+            collector.add(op);
+        }
+        let bundle = collector
+            .unbundle(&self.actors, &self.deps)
+            .map_err(|e| ParseError::Unbundle(Box::new(e)))?;
+        Ok(bundle)
+    }
+
+    pub(crate) fn iter_ops(&self) -> OpIter<'_> {
+        let bytes = &self.bytes[self.ops_data.clone()];
+        OpIter::new(&self.ops_meta, bytes)
+    }
+
+    pub(crate) fn iter_change_meta(&self) -> BundleChangeIter<'_> {
+        let change_data = &self.bytes[self.changes_data.clone()];
+        BundleChangeIter::new_from_verified(&self.changes_meta, change_data)
+    }
+
+    pub(crate) fn deps(&self) -> &[ChangeHash] {
+        &self.deps
+    }
+}

data/vendor/automerge-rust/automerge/src/storage/bundle.rs

@@ -0,0 +1,210 @@
+use crate::change_graph::ChangeGraph;
+use crate::op_set2::change::{ActorMapper, BuildChangeMetadata};
+use crate::op_set2::OpSet;
+use crate::storage::change::{Unverified, Verified};
+use crate::storage::{parse, Header};
+use crate::types::{ActorId, ChangeHash};
+use crate::{AutomergeError, Change};
+
+use std::borrow::Cow;
+
+mod builder;
+mod error;
+mod meta;
+mod storage;
+
+pub use builder::BundleChangeIter;
+
+pub(crate) use builder::{BundleBuilder, BundleChangeIterUnverified, OpIter, OpIterUnverified};
+pub(crate) use error::ParseError;
+pub(crate) use meta::BundleMetadata;
+pub(crate) use storage::BundleStorage;
+
+/// EXPERIMENTAL: A set of changes compressed into a bundle
+///
+/// Bundles are produced by [`Automerge::bundle`](crate::Automerge::bundle) and
+/// contain a set of compressed changes which is not necessarily the whole
+/// document. A bundle can be loaded using
+/// [`Automerge::load_incremental`](crate::Automerge::load_incremental) but can
+/// also be loaded using `TryFrom<&[u8]>` in order to examine the contents of
+/// the bundle.
+///
+/// This feature is experimental, the file format for bundles may still change
+/// so do not use this feature in systems where you expect data to stick around
+#[derive(Debug)]
+pub struct Bundle {
+    pub(crate) storage: BundleStorage<'static, Verified>,
+}
+
+impl Bundle {
+    pub(crate) fn for_hashes<I>(
+        op_set: &OpSet,
+        change_graph: &ChangeGraph,
+        hashes: I,
+    ) -> Result<Bundle, AutomergeError>
+    where
+        I: IntoIterator<Item = ChangeHash>,
+    {
+        let changes = change_graph
+            .get_bundle_metadata(hashes)
+            .collect::<Result<_, _>>()?;
+        Ok(Self::from_meta(op_set, changes))
+    }
+
+    fn from_meta(op_set: &OpSet, changes: Vec<BundleMetadata<'_>>) -> Bundle {
+        let min = changes
+            .iter()
+            .map(|c| c.start_op as usize)
+            .min()
+            .unwrap_or(0);
+        let max = changes.iter().map(|c| c.max_op as usize).max().unwrap_or(0) + 1;
+
+        let mapper = ActorMapper::new(&op_set.actors);
+
+        let mut collector = BundleBuilder::from_change_meta(changes, mapper);
+
+        for op in op_set.iter_ctr_range(min..max) {
+            let op_id = op.id;
+            let op_succ = op.succ();
+            collector.process_op(op);
+
+            for id in op_succ {
+                collector.process_succ(op_id, id);
+            }
+        }
+
+        collector.finish()
+    }
+
+    pub(crate) fn new_from_unverified(
+        stored: BundleStorage<'static, Unverified>,
+    ) -> Result<Self, ParseError> {
+        Ok(Self {
+            storage: stored.verify()?,
+        })
+    }
+
+    pub fn actors(&self) -> &[ActorId] {
+        &self.storage.actors
+    }
+
+    pub fn authors(&self) -> &[Vec<u8>] {
+        &[]
+    }
+
+    pub fn iter_changes(&self) -> BundleChangeIter<'_> {
+        self.storage.iter_change_meta()
+    }
+
+    pub fn to_changes(&self) -> Result<Vec<Change>, AutomergeError> {
+        self.storage
+            .to_changes()
+            .map_err(|e| AutomergeError::Unbundle(Box::new(e)))
+    }
+
+    pub fn bytes(&self) -> &[u8] {
+        &self.storage.bytes
+    }
+
+    pub fn deps(&self) -> &[ChangeHash] {
+        self.storage.deps()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct BundleChange<'a> {
+    pub actor: usize,
+    pub author: Option<usize>,
+    pub seq: u64,
+    pub start_op: u64,
+    pub max_op: u64,
+    pub timestamp: i64,
+    pub message: Option<Cow<'a, str>>,
+    pub deps: Vec<u64>,
+    pub extra: Cow<'a, [u8]>,
+}
+
+impl<'a> From<BundleChange<'a>> for BuildChangeMetadata<'a> {
+    fn from(bundle: BundleChange<'a>) -> Self {
+        BuildChangeMetadata {
+            actor: bundle.actor,
+            seq: bundle.seq,
+            start_op: bundle.start_op,
+            max_op: bundle.max_op,
+            timestamp: bundle.timestamp,
+            message: bundle.message,
+            deps: bundle.deps,
+            extra: bundle.extra,
+            builder: 0,
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a [u8]> for Bundle {
+    type Error = InvalidBundle;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self, Self::Error> {
+        let input = parse::Input::new(bytes);
+        let (i, header) = Header::parse::<crate::storage::chunk::error::Header>(input)
+            .map_err(|e| InvalidBundle(format!("invalid header: {}", e)))?;
+        let (_i, bundle) = BundleStorage::parse_following_header(i, header)
+            .map_err(|e| InvalidBundle(format!("invalid contents: {}", e)))?;
+        let verified = bundle
+            .verify()
+            .map_err(|e| InvalidBundle(format!("unable to verify ops: {}", e)))?;
+        Ok(Self {
+            storage: verified.into_owned(),
+        })
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("invalid bundle: {0}")]
+pub struct InvalidBundle(String);
+
+#[cfg(test)]
+mod test {
+    use crate::transaction::Transactable;
+    use crate::{Automerge, ROOT};
+
+    #[test]
+    fn make_bundle() {
+        let mut doc = Automerge::new();
+
+        let mut tx = doc.transaction();
+        tx.put(&ROOT, "aaa", "aaa").unwrap();
+        let (Some(h0), _) = tx.commit() else { panic!() };
+
+        let mut d2 = doc.fork();
+
+        let mut tx = doc.transaction();
+        tx.put(&ROOT, "bbb", "bbb").unwrap();
+        let (Some(h1), _) = tx.commit() else { panic!() };
+
+        let mut tx = doc.transaction();
+        tx.put(&ROOT, "ccc", "ccc").unwrap();
+        let (Some(h2), _) = tx.commit() else { panic!() };
+
+        let bundle = doc.bundle([h0, h1, h2]).unwrap();
+        let changes = bundle.to_changes().unwrap();
+        assert_eq!(changes.len(), 3);
+        assert_eq!(changes[0].max_op(), 1);
+        assert_eq!(changes[0].hash(), h0);
+        assert_eq!(changes[1].max_op(), 2);
+        assert_eq!(changes[1].hash(), h1);
+        assert_eq!(changes[2].max_op(), 3);
+        assert_eq!(changes[2].hash(), h2);
+
+        d2.load_incremental(bundle.bytes()).unwrap();
+
+        assert_eq!(doc.save(), d2.save());
+
+        let bundle = doc.bundle([h0, h2]).unwrap();
+        let changes = bundle.to_changes().unwrap();
+        assert_eq!(changes.len(), 2);
+        assert_eq!(changes[0].max_op(), 1);
+        assert_eq!(changes[0].hash(), h0);
+        assert_eq!(changes[1].max_op(), 3);
+        assert_eq!(changes[1].hash(), h2);
+    }
+}